more precise MSVC specification

Remove and replace exceptions

.travis.yml

@@ -1,17 +0,0 @@
-compiler:
-    - gcc-4.8
-
-before_install:
-    - sudo add-apt-repository --yes ppa:ubuntu-sdk-team/ppa
-    - sudo add-apt-repository --yes ppa:ubuntu-toolchain-r/test
-    - sudo apt-get update -qq
-    - sudo apt-get install -qq g++-4.8
-    - sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 40 --slave /usr/bin/g++ g++ /usr/bin/g++-4.8
-    - sudo update-alternatives --config gcc
-
-script:
-    - qmake Athena.pro
-    - make
-
-notifications:
-    irc: "irc.wiiking2.com#wiiking2"

Athena.pri

@@ -1,4 +0,0 @@
-include(AthenaCore.pri)
-include(AthenaZelda.pri)
-include(AthenaWiiSave.pri)
-include(AthenaSakura.pri)

Athena.pro

@@ -1,63 +0,0 @@
-CONFIG += staticlib c++11
-QMAKE_CXXFLAGS += -std=c++11
-TEMPLATE= lib
-DESTDIR = ./lib
-INCLUDEPATH += $$PWD/include
-
-# Uncomment this if you wish to use Qt with libAthena
-#DEFINES += ATHENA_USE_QT
-
-contains(DEFINES, ATHENA_USE_QT){
-    QT += qt core
-} else {
-    QT =
-}
-
-CONFIG(debug, debug|release): {
-    DEFINES += DEBUG
-    TARGET=Athena-d
-    # We don't want the objects,
-    # in the project directory, so tell qmake
-    # where to put them
-    OBJECTS_DIR = obj/debug
-}
-
-CONFIG(release, release|debug): {
-    DEFINES -= DEBUG
-    TARGET=Athena
-    # We don't want the objects,
-    # in the project directory, so tell qmake
-    # where to put them
-    OBJECTS_DIR = obj/release
-}
-
-ATHENA_PRO=true
-
-include(Athena.pri)
-
-
-OTHER_FILES += \
-    .travis.yml
-
-unix {
-    isEmpty(PREFIX) {
-        PREFIX = /usr/local
-    }
-    libFiles.path = $$PREFIX/lib
-    libFiles.files = $$PWD/lib/*
-    headerFiles.files = $$PWD/include/*
-    headerFiles.path = $$PREFIX/include/Athena
-    INSTALLS += libFiles headerFiles
-}
-
-win32 {
-   isEmpty(PREFIX) {
-        PREFIX = $$PWD/pkg
-   }
-
-   libFiles.path = $$PREFIX/lib
-   libFiles.files = $$PWD/lib/*
-   headerFiles.path = $$PREFIX/include/Athena
-   headerFiles.files = $$PWD/include/*
-   INSTALLS += libFiles headerFiles
-}

AthenaConfig.cmake.in

@@ -0,0 +1,22 @@
+# - Config file for the Athena package
+# It defines the following variables
+#  ATHENA_INCLUDE_DIR  - include directory for Athena
+#  ATHENA_LIBRARIES    - libraries to link against
+#  ATHENA_ICON         - path to Athena.ico
+ 
+# Compute paths
+get_filename_component(ATHENA_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
+set(ATHENA_INCLUDE_DIR "@CONF_INCLUDE_DIR@")
+ 
+# Our library dependencies (contains definitions for IMPORTED targets)
+if(NOT TARGET AthenaCore AND NOT Athena_BINARY_DIR)
+  include("${ATHENA_CMAKE_DIR}/AthenaTargets.cmake")
+endif()
+ 
+# These are IMPORTED targets created by AthenaTargets.cmake
+set(ATHENA_LIBRARIES AthenaCore AthenaSakura AthenaZelda AthenaWiiSave)
+
+# Set icon location if on windows
+if(WIN32 AND NOT CYGWIN)
+set(ATHENA_ICON "@CONF_ICON_DIR@")
+endif()

AthenaConfigVersion.cmake.in

@@ -0,0 +1,11 @@
+set(PACKAGE_VERSION "@ATHENA_VERSION@")
+ 
+# Check whether the requested PACKAGE_FIND_VERSION is compatible
+if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}")
+  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+  set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  if ("${PACKAGE_VERSION}" VERSION_EQUAL "${PACKAGE_FIND_VERSION}")
+    set(PACKAGE_VERSION_EXACT TRUE)
+  endif()
+endif()

AthenaCore.pri

@@ -1,66 +0,0 @@
-!contains(ATHENA_PRO, true): {
-    INCLUDEPATH += $$PWD/include
-    !contains(CONFIG, c++11):CONFIG += c++11
-    mac:QMAKE_CXXFLAGS += -stdlib=libc++
-}
-
-include(extern/lzo/lzo.pri)
-include(extern/zlib/zlib.pri)
-
-ATHENA_CORE=true
-
-SOURCES += \
-    $$PWD/src/Athena/Utility.cpp \
-    $$PWD/src/Athena/FileReader.cpp \
-    $$PWD/src/Athena/FileWriter.cpp \
-    $$PWD/src/Athena/MemoryReader.cpp \
-    $$PWD/src/Athena/MemoryWriter.cpp \
-    $$PWD/src/Athena/Global.cpp \
-    $$PWD/src/Athena/Checksums.cpp \
-    $$PWD/src/Athena/Compression.cpp \
-    $$PWD/src/LZ77/LZLookupTable.cpp \
-    $$PWD/src/LZ77/LZType10.cpp \
-    $$PWD/src/LZ77/LZType11.cpp \
-    $$PWD/src/LZ77/LZBase.cpp
-
-win32:SOURCES += \
-    $$PWD/src/win32_largefilewrapper.c
-
-mac:SOURCES += \
-    $$PWD/src/osx_largefilewrapper.c
-
-
-HEADERS += \
-    $$PWD/include/Athena/IStream.hpp \
-    $$PWD/include/Athena/IStreamReader.hpp \
-    $$PWD/include/Athena/IStreamWriter.hpp \
-    $$PWD/include/Athena/Types.hpp \
-    $$PWD/include/Athena/Utility.hpp \
-    $$PWD/include/Athena/Global.hpp \
-    $$PWD/include/Athena/Exception.hpp \
-    $$PWD/include/Athena/FileNotFoundException.hpp \
-    $$PWD/include/Athena/IOException.hpp \
-    $$PWD/include/Athena/InvalidDataException.hpp \
-    $$PWD/include/Athena/InvalidOperationException.hpp \
-    $$PWD/include/Athena/FileReader.hpp \
-    $$PWD/include/Athena/FileWriter.hpp \
-    $$PWD/include/Athena/MemoryReader.hpp \
-    $$PWD/include/Athena/MemoryWriter.hpp \
-    $$PWD/include/Athena/NotImplementedException.hpp \
-    $$PWD/include/Athena/Checksums.hpp \
-    $$PWD/include/Athena/Compression.hpp \
-    $$PWD/include/LZ77/LZBase.hpp \
-    $$PWD/include/LZ77/LZLookupTable.hpp \
-    $$PWD/include/LZ77/LZType10.hpp \
-    $$PWD/include/LZ77/LZType11.hpp \
-    $$PWD/include/utf8.h \
-    $$PWD/include/utf8/checked.h \
-    $$PWD/include/utf8/core.h \
-    $$PWD/include/utf8/unchecked.h
-
-win32:HEADERS += \
-    $$PWD/include/win32_largefilewrapper.h
-
-mac:HEADERS += \
-    $$PWD/include/osx_largefilewrapper.h
-

AthenaSakura.pri

@@ -1,20 +0,0 @@
-!contains(ATHENA_CORE, true): {
-    message("including core")
-    include(AthenaCore.pri)
-}
-
-SOURCES += \
-    $$PWD/src/Athena/Sprite.cpp \
-    $$PWD/src/Athena/SpriteFile.cpp \
-    $$PWD/src/Athena/SpriteFileReader.cpp \
-    $$PWD/src/Athena/SpriteFileWriter.cpp \
-    $$PWD/src/Athena/SpriteFrame.cpp \
-    $$PWD/src/Athena/SpritePart.cpp
-
-HEADERS += \
-    $$PWD/include/Athena/Sprite.hpp \
-    $$PWD/include/Athena/SpriteFile.hpp \
-    $$PWD/include/Athena/SpriteFileReader.hpp \
-    $$PWD/include/Athena/SpriteFileWriter.hpp \
-    $$PWD/include/Athena/SpriteFrame.hpp \
-    $$PWD/include/Athena/SpritePart.hpp

AthenaWiiSave.pri

@@ -1,30 +0,0 @@
-!contains(ATHENA_CORE, true): {
-    message("including core")
-    include(AthenaCore.pri)
-}
-
-SOURCES += \
-    $$PWD/src/Athena/WiiBanner.cpp \
-    $$PWD/src/Athena/WiiFile.cpp \
-    $$PWD/src/Athena/WiiImage.cpp \
-    $$PWD/src/Athena/WiiSave.cpp \
-    $$PWD/src/Athena/WiiSaveReader.cpp \
-    $$PWD/src/Athena/WiiSaveWriter.cpp \
-    $$PWD/src/bn.cpp \
-    $$PWD/src/ec.cpp \
-    $$PWD/src/md5.cpp \
-    $$PWD/src/sha1.cpp \
-    $$PWD/src/aes.c
-
-HEADERS += \
-    $$PWD/include/Athena/WiiBanner.hpp \
-    $$PWD/include/Athena/WiiFile.hpp \
-    $$PWD/include/Athena/WiiImage.hpp \
-    $$PWD/include/Athena/WiiSave.hpp \
-    $$PWD/include/Athena/WiiSaveReader.hpp \
-    $$PWD/include/Athena/WiiSaveWriter.hpp \
-    $$PWD/include/aes.h \
-    $$PWD/include/bn.h \
-    $$PWD/include/ec.h \
-    $$PWD/include/md5.h \
-    $$PWD/include/sha1.h

AthenaZelda.pri

@@ -1,36 +0,0 @@
-!contains(ATHENA_CORE, true): {
-    message("including core")
-    include(AthenaCore.pri)
-}
-
-SOURCES += \
-    $$PWD/src/Athena/ALTTPFile.cpp \
-    $$PWD/src/Athena/ALTTPFileReader.cpp \
-    $$PWD/src/Athena/ALTTPFileWriter.cpp \
-    $$PWD/src/Athena/ALTTPQuest.cpp \
-    $$PWD/src/Athena/MCFile.cpp \
-    $$PWD/src/Athena/MCFileReader.cpp \
-    $$PWD/src/Athena/MCFileWriter.cpp \
-    $$PWD/src/Athena/MCSlot.cpp \
-    $$PWD/src/Athena/SkywardSwordFile.cpp \
-    $$PWD/src/Athena/SkywardSwordFileReader.cpp \
-    $$PWD/src/Athena/SkywardSwordFileWriter.cpp \
-    $$PWD/src/Athena/SkywardSwordQuest.cpp \
-    $$PWD/src/Athena/ZQuestFile.cpp \
-    $$PWD/src/Athena/ZQuestFileReader.cpp \
-    $$PWD/src/Athena/ZQuestFileWriter.cpp
-
-HEADERS += \
-    $$PWD/include/Athena/ALTTPEnums.hpp \
-    $$PWD/include/Athena/ALTTPFile.hpp \
-    $$PWD/include/Athena/ALTTPFileReader.hpp \
-    $$PWD/include/Athena/ALTTPFileWriter.hpp \
-    $$PWD/include/Athena/ALTTPQuest.hpp \
-    $$PWD/include/Athena/ALTTPStructs.hpp \
-    $$PWD/include/Athena/MCFile.hpp \
-    $$PWD/include/Athena/MCFileReader.hpp \
-    $$PWD/include/Athena/MCFileWriter.hpp \
-    $$PWD/include/Athena/SkywardSwordFile.hpp \
-    $$PWD/include/Athena/SkywardSwordFileReader.hpp \
-    $$PWD/include/Athena/SkywardSwordFileWriter.hpp \
-    $$PWD/include/Athena/SkywardSwordQuest.hpp

CMakeLists.txt

@@ -0,0 +1,250 @@
+cmake_minimum_required(VERSION 3.0)
+project(Athena)
+
+##################
+# Athena Version #
+##################
+
+set(ATHENA_MAJOR_VERSION 2)
+set(ATHENA_MINOR_VERSION 2)
+set(ATHENA_PATCH_VERSION 0)
+set(ATHENA_VERSION
+  ${ATHENA_MAJOR_VERSION}.${ATHENA_MINOR_VERSION}.${ATHENA_PATCH_VERSION})
+
+################
+# Athena Build #
+################
+
+add_subdirectory(extern)
+
+include_directories(include ${LZO_INCLUDE_DIR} ${ZLIB_INCLUDE_DIR})
+if (NOT MSVC)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+endif()
+
+if(WIN32)
+list(APPEND CORE_EXTRA src/win32_largefilewrapper.c)
+elseif(APPLE)
+list(APPEND CORE_EXTRA src/osx_largefilewrapper.c)
+elseif(GEKKO)
+list(APPEND CORE_EXTRA src/gekko_support.c)
+endif()
+
+add_library(AthenaCore
+    src/Athena/Utility.cpp
+    src/Athena/FileReader.cpp
+    src/Athena/FileWriter.cpp
+    src/Athena/MemoryReader.cpp
+    src/Athena/MemoryWriter.cpp
+    src/Athena/Global.cpp
+    src/Athena/Checksums.cpp
+    src/Athena/Compression.cpp
+    src/LZ77/LZLookupTable.cpp
+    src/LZ77/LZType10.cpp
+    src/LZ77/LZType11.cpp
+    src/LZ77/LZBase.cpp
+    src/Athena/FileInfo.cpp
+    src/Athena/Dir.cpp
+    ${CORE_EXTRA}
+
+    include/Athena/IStream.hpp
+    include/Athena/IStreamReader.hpp
+    include/Athena/IStreamWriter.hpp
+    include/Athena/Types.hpp
+    include/Athena/Utility.hpp
+    include/Athena/Global.hpp
+    include/Athena/FileReader.hpp
+    include/Athena/FileWriter.hpp
+    include/Athena/MemoryReader.hpp
+    include/Athena/MemoryWriter.hpp
+    include/Athena/Checksums.hpp
+    include/Athena/Compression.hpp
+    include/LZ77/LZBase.hpp
+    include/LZ77/LZLookupTable.hpp
+    include/LZ77/LZType10.hpp
+    include/LZ77/LZType11.hpp
+    include/Athena/FileInfo.hpp
+    include/Athena/Dir.hpp
+    include/gekko_support.h
+    include/Athena/DNA.hpp
+)
+
+add_library(AthenaSakura
+    src/Athena/Sprite.cpp
+    src/Athena/SpriteFile.cpp
+    src/Athena/SpriteFileReader.cpp
+    src/Athena/SpriteFileWriter.cpp
+    src/Athena/SpriteFrame.cpp
+    src/Athena/SpritePart.cpp
+
+    include/Athena/Sprite.hpp
+    include/Athena/SpriteFile.hpp
+    include/Athena/SpriteFileReader.hpp
+    include/Athena/SpriteFileWriter.hpp
+    include/Athena/SpriteFrame.hpp
+    include/Athena/SpritePart.hpp
+)
+
+add_library(AthenaWiiSave
+    src/Athena/WiiBanner.cpp
+    src/Athena/WiiFile.cpp
+    src/Athena/WiiImage.cpp
+    src/Athena/WiiSave.cpp
+    src/Athena/WiiSaveReader.cpp
+    src/Athena/WiiSaveWriter.cpp
+    src/bn.cpp
+    src/ec.cpp
+    src/md5.cpp
+    src/sha1.cpp
+    src/aes.cpp
+
+    include/Athena/WiiBanner.hpp
+    include/Athena/WiiFile.hpp
+    include/Athena/WiiImage.hpp
+    include/Athena/WiiSave.hpp
+    include/Athena/WiiSaveReader.hpp
+    include/Athena/WiiSaveWriter.hpp
+    include/aes.hpp
+    include/bn.h
+    include/ec.h
+    include/md5.h
+    include/sha1.h
+)
+if(NOT MSVC)
+set_source_files_properties(src/aes.cpp PROPERTIES COMPILE_FLAGS -maes)
+endif()
+
+add_library(AthenaZelda
+    src/Athena/ALTTPFile.cpp
+    src/Athena/ALTTPFileReader.cpp
+    src/Athena/ALTTPFileWriter.cpp
+    src/Athena/ALTTPQuest.cpp
+    src/Athena/MCFile.cpp
+    src/Athena/MCFileReader.cpp
+    src/Athena/MCFileWriter.cpp
+    src/Athena/MCSlot.cpp
+    src/Athena/SkywardSwordFile.cpp
+    src/Athena/SkywardSwordFileReader.cpp
+    src/Athena/SkywardSwordFileWriter.cpp
+    src/Athena/SkywardSwordQuest.cpp
+    src/Athena/ZQuestFile.cpp
+    src/Athena/ZQuestFileReader.cpp
+    src/Athena/ZQuestFileWriter.cpp
+
+    include/Athena/ALTTPEnums.hpp
+    include/Athena/ALTTPFile.hpp
+    include/Athena/ALTTPFileReader.hpp
+    include/Athena/ALTTPFileWriter.hpp
+    include/Athena/ALTTPQuest.hpp
+    include/Athena/ALTTPStructs.hpp
+    include/Athena/MCFile.hpp
+    include/Athena/MCFileReader.hpp
+    include/Athena/MCFileWriter.hpp
+    include/Athena/SkywardSwordFile.hpp
+    include/Athena/SkywardSwordFileReader.hpp
+    include/Athena/SkywardSwordFileWriter.hpp
+    include/Athena/SkywardSwordQuest.hpp
+)
+
+# Offer the user the choice of overriding the installation directories
+set(INSTALL_LIB_DIR lib CACHE PATH "Installation directory for libraries")
+set(INSTALL_INCLUDE_DIR include CACHE PATH "Installation directory for header files")
+if(WIN32 AND NOT CYGWIN)
+  set(INSTALL_CMAKE_DIR cmake)
+else()
+  set(INSTALL_CMAKE_DIR lib/cmake/Athena)
+endif()
+
+# Make relative paths absolute (needed later on)
+foreach(p LIB INCLUDE CMAKE)
+  set(var INSTALL_${p}_DIR)
+  if(NOT IS_ABSOLUTE "${${var}}")
+    set(ABS_${var} "${CMAKE_INSTALL_PREFIX}/${${var}}")
+  else()
+    set(ABS_${var} "${${var}}")
+  endif()
+endforeach()
+
+# Define installs
+install(DIRECTORY include/ DESTINATION ${INSTALL_INCLUDE_DIR}/Athena COMPONENT Athena)
+install(TARGETS AthenaCore AthenaSakura AthenaWiiSave AthenaZelda
+        DESTINATION ${INSTALL_LIB_DIR} EXPORT AthenaTargets COMPONENT Athena)
+if(WIN32 AND NOT CYGWIN)
+install(FILES Athena.ico DESTINATION ${INSTALL_LIB_DIR} COMPONENT Athena)
+elseif(UNIX)
+configure_file(libAthena.pc.in libAthena.pc @ONLY)
+install(FILES ${PROJECT_BINARY_DIR}/libAthena.pc 
+        DESTINATION ${INSTALL_LIB_DIR}/pkgconfig COMPONENT Athena)
+endif()
+
+##################
+# Package Export #
+##################
+
+# Add all targets to the build-tree export set
+export(TARGETS AthenaCore AthenaSakura AthenaWiiSave AthenaZelda
+  FILE "${PROJECT_BINARY_DIR}/AthenaTargets.cmake")
+
+# Export the package for use from the build-tree
+# (this registers the build-tree with a global CMake-registry)
+export(PACKAGE Athena)
+
+# Create the AthenaConfig.cmake
+# ... for the build tree
+set(CONF_INCLUDE_DIR "${PROJECT_SOURCE_DIR}/include/Athena")
+set(CONF_ICON_DIR "${PROJECT_SOURCE_DIR}/Athena.ico")
+configure_file(AthenaConfig.cmake.in "${PROJECT_BINARY_DIR}/AthenaConfig.cmake" @ONLY)
+# ... for the install tree
+file(RELATIVE_PATH REL_INCLUDE_DIR "${ABS_INSTALL_CMAKE_DIR}" "${ABS_INSTALL_INCLUDE_DIR}")
+file(RELATIVE_PATH REL_ICON_DIR "${ABS_INSTALL_CMAKE_DIR}" "${ABS_INSTALL_LIB_DIR}/Athena.ico")
+set(CONF_INCLUDE_DIR "\${ATHENA_CMAKE_DIR}/${REL_INCLUDE_DIR}/Athena")
+set(CONF_ICON_DIR "\${ATHENA_CMAKE_DIR}/${REL_ICON_DIR}")
+configure_file(AthenaConfig.cmake.in "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/AthenaConfig.cmake" @ONLY)
+# ... for both
+configure_file(AthenaConfigVersion.cmake.in "${PROJECT_BINARY_DIR}/AthenaConfigVersion.cmake" @ONLY)
+
+# Install AthenaConfig.cmake
+install(FILES
+  "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/AthenaConfig.cmake"
+  "${PROJECT_BINARY_DIR}/AthenaConfigVersion.cmake"
+  DESTINATION ${INSTALL_CMAKE_DIR} COMPONENT Athena)
+
+# Install the export set for use with the install-tree
+install(EXPORT AthenaTargets DESTINATION ${INSTALL_CMAKE_DIR} COMPONENT Athena)
+
+################
+# atdna import #
+################
+
+if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/atdna/CMakeLists.txt")
+  add_subdirectory(atdna)
+endif()
+
+#########
+# CPack #
+#########
+
+include(InstallRequiredSystemLibraries)
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Athena")
+set(CPACK_PACKAGE_VENDOR "Antidote / Jackoalan")
+set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
+set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
+set(CPACK_PACKAGE_VERSION_MAJOR ${ATHENA_MAJOR_VERSION})
+set(CPACK_PACKAGE_VERSION_MINOR ${ATHENA_MINOR_VERSION})
+set(CPACK_PACKAGE_VERSION_PATCH ${ATHENA_PATCH_VERSION})
+set(CPACK_PACKAGE_INSTALL_DIRECTORY "Athena")
+if(WIN32 AND NOT UNIX)
+    # There is a bug in NSI that does not handle full unix paths properly. Make
+    # sure there is at least one set of four (4) backlasshes.
+    set(CPACK_PACKAGE_INSTALL_REGISTRY_KEY "Athena")
+    set(CPACK_PACKAGE_ICON "${CMAKE_CURRENT_SOURCE_DIR}\\\\AthenaNSIS.bmp")
+    set(CPACK_NSIS_MODIFY_PATH ON)
+    set(CPACK_NSIS_MUI_ICON "${CMAKE_CURRENT_SOURCE_DIR}\\\\Athena.ico")
+    set(CPACK_NSIS_MUI_UNIICON "${CMAKE_CURRENT_SOURCE_DIR}\\\\Athena.ico")
+    set(CPACK_NSIS_INSTALLED_ICON_NAME "Uninstall.exe")
+    set(CPACK_NSIS_DISPLAY_NAME "Athena")
+    set(CPACK_NSIS_URL_INFO_ABOUT "http://libathena.github.io")
+    set(CPACK_NSIS_CONTACT "antidote.crk@gmail.com")
+endif()
+include(CPack)
+

LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011-2015 Phillip "Antidote" Stephens, Jack Andersen, et al.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

PKGBUILD

@@ -1,14 +1,14 @@
 # PKGBUILD for libAthena
 _pkgname=libathena
 pkgname=$_pkgname-git
-pkgver=v1.0.0
+pkgver=2.1.0
 pkgrel=1
 pkgdesc="Basic cross platform IO library"
 arch=('i686' 'x86_64')
-source=("${pkgname%-*}::git+https://github.com/Antidote/Athena.git")
+source=("${pkgname%-*}::git+https://github.com/libAthena/Athena.git")
 options=(staticlibs)
-license="GPL3"
-makedepends=('git qt5-base sed')
+license="MIT"
+makedepends=('git cmake sed')
 md5sums=('SKIP')
 sha256sums=('SKIP')
 
@@ -19,11 +19,14 @@ pkgver() {
 
 build() {
     cd "$srcdir/$_pkgname"
-    qmake && make
+    mkdir -p build
+    cd build
+    cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX="$pkgdir/usr" ..
+    make
 }
 
 package() {
-    cd "$srcdir/$_pkgname"
-	qmake PREFIX="$pkgdir/usr" && make install
+    cd "$srcdir/$_pkgname/build"
+	make install
 }
 

README.md

@@ -1,2 +1 @@
 # Athena
-[![Build Status](https://travis-ci.org/Antidote/Athena.svg?branch=master)](https://travis-ci.org/Antidote/Athena)

extern/CMakeLists.txt

@@ -0,0 +1,2 @@
+add_subdirectory(lzo)
+add_subdirectory(zlib)

extern/lzo/CMakeLists.txt

@@ -0,0 +1,85 @@
+if(NOT WIN32)
+find_library(LZO_LIB lzo2)
+endif()
+if(WIN32 OR LZO_LIB STREQUAL LZO_LIB-NOTFOUND)
+include_directories(include)
+message("-- Using Athena's built-in lzo")
+add_library(lzo2
+    src/lzo1.c
+    src/lzo1_99.c
+    src/lzo1a.c
+    src/lzo1a_99.c
+    src/lzo1b_1.c
+    src/lzo1b_2.c
+    src/lzo1b_3.c
+    src/lzo1b_4.c
+    src/lzo1b_5.c
+    src/lzo1b_6.c
+    src/lzo1b_7.c
+    src/lzo1b_8.c
+    src/lzo1b_9.c
+    src/lzo1b_99.c
+    src/lzo1b_9x.c
+    src/lzo1b_cc.c
+    src/lzo1b_d1.c
+    src/lzo1b_d2.c
+    src/lzo1b_rr.c
+    src/lzo1b_xx.c
+    src/lzo1c_1.c
+    src/lzo1c_2.c
+    src/lzo1c_3.c
+    src/lzo1c_4.c
+    src/lzo1c_5.c
+    src/lzo1c_6.c
+    src/lzo1c_7.c
+    src/lzo1c_8.c
+    src/lzo1c_9.c
+    src/lzo1c_99.c
+    src/lzo1c_9x.c
+    src/lzo1c_cc.c
+    src/lzo1c_d1.c
+    src/lzo1c_d2.c
+    src/lzo1c_rr.c
+    src/lzo1c_xx.c
+    src/lzo1f_1.c
+    src/lzo1f_9x.c
+    src/lzo1f_d1.c
+    src/lzo1f_d2.c
+    src/lzo1x_1.c
+    src/lzo1x_1k.c
+    src/lzo1x_1l.c
+    src/lzo1x_1o.c
+    src/lzo1x_9x.c
+    src/lzo1x_d1.c
+    src/lzo1x_d2.c
+    src/lzo1x_d3.c
+    src/lzo1x_o.c
+    src/lzo1y_1.c
+    src/lzo1y_9x.c
+    src/lzo1y_d1.c
+    src/lzo1y_d2.c
+    src/lzo1y_d3.c
+    src/lzo1y_o.c
+    src/lzo1z_9x.c
+    src/lzo1z_d1.c
+    src/lzo1z_d2.c
+    src/lzo1z_d3.c
+    src/lzo2a_9x.c
+    src/lzo2a_d1.c
+    src/lzo2a_d2.c
+    src/lzo_crc.c
+    src/lzo_init.c
+    src/lzo_ptr.c
+    src/lzo_str.c
+    src/lzo_util.c
+    include/lzo/lzo1.h
+    include/lzo/lzo1x.h
+    include/lzo/lzoconf.h
+    include/lzo/lzodefs.h
+    include/lzo/lzoutil.h)
+if(WIN32 AND NOT UNIX)
+install(DIRECTORY include/lzo DESTINATION include COMPONENT lzo2)
+install(TARGETS lzo2 DESTINATION lib COMPONENT lzo2)
+endif()
+set(LZO_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include CACHE PATH "LZO include path" FORCE)
+endif()

extern/lzo/include/lzo/lzo1.h

@@ -51,14 +51,14 @@ extern "C" {
 
 
 LZO_EXTERN(int)
-lzo1_compress           ( const lzo_bytep src, lzo_uint  src_len,
+lzo1_compress(const lzo_bytep src, lzo_uint  src_len,
               lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+              lzo_voidp wrkmem);
 
 LZO_EXTERN(int)
-lzo1_decompress         ( const lzo_bytep src, lzo_uint  src_len,
+lzo1_decompress(const lzo_bytep src, lzo_uint  src_len,
                 lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem /* NOT USED */ );
+                lzo_voidp wrkmem /* NOT USED */);
 
 
 /***********************************************************************
@@ -68,9 +68,9 @@ lzo1_decompress         ( const lzo_bytep src, lzo_uint  src_len,
 #define LZO1_99_MEM_COMPRESS    ((lzo_uint32_t) (65536L * lzo_sizeof_dict_t))
 
 LZO_EXTERN(int)
-lzo1_99_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1_99_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 
 
 

extern/lzo/include/lzo/lzo1a.h

@@ -51,14 +51,14 @@ extern "C" {
 
 
 LZO_EXTERN(int)
-lzo1a_compress          ( const lzo_bytep src, lzo_uint  src_len,
+lzo1a_compress(const lzo_bytep src, lzo_uint  src_len,
                lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+               lzo_voidp wrkmem);
 
 LZO_EXTERN(int)
-lzo1a_decompress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1a_decompress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem /* NOT USED */ );
+                 lzo_voidp wrkmem /* NOT USED */);
 
 
 /***********************************************************************
@@ -68,9 +68,9 @@ lzo1a_decompress        ( const lzo_bytep src, lzo_uint  src_len,
 #define LZO1A_99_MEM_COMPRESS   ((lzo_uint32_t) (65536L * lzo_sizeof_dict_t))
 
 LZO_EXTERN(int)
-lzo1a_99_compress       ( const lzo_bytep src, lzo_uint  src_len,
+lzo1a_99_compress(const lzo_bytep src, lzo_uint  src_len,
                   lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                  lzo_voidp wrkmem);
 
 
 

extern/lzo/include/lzo/lzo1b.h

@@ -57,22 +57,22 @@ extern "C" {
 
 
 LZO_EXTERN(int)
-lzo1b_compress          ( const lzo_bytep src, lzo_uint  src_len,
+lzo1b_compress(const lzo_bytep src, lzo_uint  src_len,
                lzo_bytep dst, lzo_uintp dst_len,
                lzo_voidp wrkmem,
-                                int compression_level );
+               int compression_level);
 
 /* decompression */
 LZO_EXTERN(int)
-lzo1b_decompress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1b_decompress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem /* NOT USED */ );
+                 lzo_voidp wrkmem /* NOT USED */);
 
 /* safe decompression with overrun testing */
 LZO_EXTERN(int)
-lzo1b_decompress_safe   ( const lzo_bytep src, lzo_uint  src_len,
+lzo1b_decompress_safe(const lzo_bytep src, lzo_uint  src_len,
                       lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem /* NOT USED */ );
+                      lzo_voidp wrkmem /* NOT USED */);
 
 
 /***********************************************************************
@@ -80,41 +80,41 @@ lzo1b_decompress_safe   ( const lzo_bytep src, lzo_uint  src_len,
 ************************************************************************/
 
 LZO_EXTERN(int)
-lzo1b_1_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1b_1_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 LZO_EXTERN(int)
-lzo1b_2_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1b_2_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 LZO_EXTERN(int)
-lzo1b_3_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1b_3_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 LZO_EXTERN(int)
-lzo1b_4_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1b_4_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 LZO_EXTERN(int)
-lzo1b_5_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1b_5_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 LZO_EXTERN(int)
-lzo1b_6_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1b_6_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 LZO_EXTERN(int)
-lzo1b_7_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1b_7_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 LZO_EXTERN(int)
-lzo1b_8_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1b_8_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 LZO_EXTERN(int)
-lzo1b_9_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1b_9_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 
 
 /***********************************************************************
@@ -124,17 +124,17 @@ lzo1b_9_compress        ( const lzo_bytep src, lzo_uint  src_len,
 #define LZO1B_99_MEM_COMPRESS   ((lzo_uint32_t) (65536L * lzo_sizeof_dict_t))
 
 LZO_EXTERN(int)
-lzo1b_99_compress       ( const lzo_bytep src, lzo_uint  src_len,
+lzo1b_99_compress(const lzo_bytep src, lzo_uint  src_len,
                   lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                  lzo_voidp wrkmem);
 
 
 #define LZO1B_999_MEM_COMPRESS  ((lzo_uint32_t) (3 * 65536L * sizeof(lzo_xint)))
 
 LZO_EXTERN(int)
-lzo1b_999_compress      ( const lzo_bytep src, lzo_uint  src_len,
+lzo1b_999_compress(const lzo_bytep src, lzo_uint  src_len,
                    lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                   lzo_voidp wrkmem);
 
 
 

extern/lzo/include/lzo/lzo1c.h

@@ -57,22 +57,22 @@ extern "C" {
 
 
 LZO_EXTERN(int)
-lzo1c_compress          ( const lzo_bytep src, lzo_uint  src_len,
+lzo1c_compress(const lzo_bytep src, lzo_uint  src_len,
                lzo_bytep dst, lzo_uintp dst_len,
                lzo_voidp wrkmem,
-                                int compression_level );
+               int compression_level);
 
 /* decompression */
 LZO_EXTERN(int)
-lzo1c_decompress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1c_decompress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem /* NOT USED */ );
+                 lzo_voidp wrkmem /* NOT USED */);
 
 /* safe decompression with overrun testing */
 LZO_EXTERN(int)
-lzo1c_decompress_safe   ( const lzo_bytep src, lzo_uint  src_len,
+lzo1c_decompress_safe(const lzo_bytep src, lzo_uint  src_len,
                       lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem /* NOT USED */ );
+                      lzo_voidp wrkmem /* NOT USED */);
 
 
 /***********************************************************************
@@ -80,41 +80,41 @@ lzo1c_decompress_safe   ( const lzo_bytep src, lzo_uint  src_len,
 ************************************************************************/
 
 LZO_EXTERN(int)
-lzo1c_1_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1c_1_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 LZO_EXTERN(int)
-lzo1c_2_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1c_2_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 LZO_EXTERN(int)
-lzo1c_3_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1c_3_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 LZO_EXTERN(int)
-lzo1c_4_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1c_4_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 LZO_EXTERN(int)
-lzo1c_5_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1c_5_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 LZO_EXTERN(int)
-lzo1c_6_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1c_6_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 LZO_EXTERN(int)
-lzo1c_7_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1c_7_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 LZO_EXTERN(int)
-lzo1c_8_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1c_8_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 LZO_EXTERN(int)
-lzo1c_9_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1c_9_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 
 
 /***********************************************************************
@@ -124,17 +124,17 @@ lzo1c_9_compress        ( const lzo_bytep src, lzo_uint  src_len,
 #define LZO1C_99_MEM_COMPRESS   ((lzo_uint32_t) (65536L * lzo_sizeof_dict_t))
 
 LZO_EXTERN(int)
-lzo1c_99_compress       ( const lzo_bytep src, lzo_uint  src_len,
+lzo1c_99_compress(const lzo_bytep src, lzo_uint  src_len,
                   lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                  lzo_voidp wrkmem);
 
 
 #define LZO1C_999_MEM_COMPRESS  ((lzo_uint32_t) (5 * 16384L * sizeof(short)))
 
 LZO_EXTERN(int)
-lzo1c_999_compress      ( const lzo_bytep src, lzo_uint  src_len,
+lzo1c_999_compress(const lzo_bytep src, lzo_uint  src_len,
                    lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                   lzo_voidp wrkmem);
 
 
 

extern/lzo/include/lzo/lzo1f.h

@@ -52,15 +52,15 @@ extern "C" {
 
 /* decompression */
 LZO_EXTERN(int)
-lzo1f_decompress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1f_decompress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem /* NOT USED */ );
+                 lzo_voidp wrkmem /* NOT USED */);
 
 /* safe decompression with overrun testing */
 LZO_EXTERN(int)
-lzo1f_decompress_safe   ( const lzo_bytep src, lzo_uint  src_len,
+lzo1f_decompress_safe(const lzo_bytep src, lzo_uint  src_len,
                       lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem /* NOT USED */ );
+                      lzo_voidp wrkmem /* NOT USED */);
 
 
 /***********************************************************************
@@ -68,9 +68,9 @@ lzo1f_decompress_safe   ( const lzo_bytep src, lzo_uint  src_len,
 ************************************************************************/
 
 LZO_EXTERN(int)
-lzo1f_1_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1f_1_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 
 
 /***********************************************************************
@@ -80,9 +80,9 @@ lzo1f_1_compress        ( const lzo_bytep src, lzo_uint  src_len,
 #define LZO1F_999_MEM_COMPRESS  ((lzo_uint32_t) (5 * 16384L * sizeof(short)))
 
 LZO_EXTERN(int)
-lzo1f_999_compress      ( const lzo_bytep src, lzo_uint  src_len,
+lzo1f_999_compress(const lzo_bytep src, lzo_uint  src_len,
                    lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                   lzo_voidp wrkmem);
 
 
 

extern/lzo/include/lzo/lzo1x.h

@@ -53,15 +53,15 @@ extern "C" {
 
 /* decompression */
 LZO_EXTERN(int)
-lzo1x_decompress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1x_decompress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem /* NOT USED */ );
+                 lzo_voidp wrkmem /* NOT USED */);
 
 /* safe decompression with overrun testing */
 LZO_EXTERN(int)
-lzo1x_decompress_safe   ( const lzo_bytep src, lzo_uint  src_len,
+lzo1x_decompress_safe(const lzo_bytep src, lzo_uint  src_len,
                       lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem /* NOT USED */ );
+                      lzo_voidp wrkmem /* NOT USED */);
 
 
 /***********************************************************************
@@ -71,9 +71,9 @@ lzo1x_decompress_safe   ( const lzo_bytep src, lzo_uint  src_len,
 #define LZO1X_1_MEM_COMPRESS    ((lzo_uint32_t) (16384L * lzo_sizeof_dict_t))
 
 LZO_EXTERN(int)
-lzo1x_1_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1x_1_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 
 
 /***********************************************************************
@@ -84,27 +84,27 @@ lzo1x_1_compress        ( const lzo_bytep src, lzo_uint  src_len,
 #define LZO1X_1_11_MEM_COMPRESS ((lzo_uint32_t) (2048L * lzo_sizeof_dict_t))
 
 LZO_EXTERN(int)
-lzo1x_1_11_compress     ( const lzo_bytep src, lzo_uint  src_len,
+lzo1x_1_11_compress(const lzo_bytep src, lzo_uint  src_len,
                     lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                    lzo_voidp wrkmem);
 
 
 /* this version needs 16 KiB work memory */
 #define LZO1X_1_12_MEM_COMPRESS ((lzo_uint32_t) (4096L * lzo_sizeof_dict_t))
 
 LZO_EXTERN(int)
-lzo1x_1_12_compress     ( const lzo_bytep src, lzo_uint  src_len,
+lzo1x_1_12_compress(const lzo_bytep src, lzo_uint  src_len,
                     lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                    lzo_voidp wrkmem);
 
 
 /* use this version if you need a little more compression speed */
 #define LZO1X_1_15_MEM_COMPRESS ((lzo_uint32_t) (32768L * lzo_sizeof_dict_t))
 
 LZO_EXTERN(int)
-lzo1x_1_15_compress     ( const lzo_bytep src, lzo_uint  src_len,
+lzo1x_1_15_compress(const lzo_bytep src, lzo_uint  src_len,
                     lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                    lzo_voidp wrkmem);
 
 
 /***********************************************************************
@@ -114,9 +114,9 @@ lzo1x_1_15_compress     ( const lzo_bytep src, lzo_uint  src_len,
 #define LZO1X_999_MEM_COMPRESS  ((lzo_uint32_t) (14 * 16384L * sizeof(short)))
 
 LZO_EXTERN(int)
-lzo1x_999_compress      ( const lzo_bytep src, lzo_uint  src_len,
+lzo1x_999_compress(const lzo_bytep src, lzo_uint  src_len,
                    lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                   lzo_voidp wrkmem);
 
 
 /***********************************************************************
@@ -124,24 +124,24 @@ lzo1x_999_compress      ( const lzo_bytep src, lzo_uint  src_len,
 ************************************************************************/
 
 LZO_EXTERN(int)
-lzo1x_999_compress_dict     ( const lzo_bytep src, lzo_uint  src_len,
+lzo1x_999_compress_dict(const lzo_bytep src, lzo_uint  src_len,
                         lzo_bytep dst, lzo_uintp dst_len,
                         lzo_voidp wrkmem,
-                              const lzo_bytep dict, lzo_uint dict_len );
+                        const lzo_bytep dict, lzo_uint dict_len);
 
 LZO_EXTERN(int)
-lzo1x_999_compress_level    ( const lzo_bytep src, lzo_uint  src_len,
+lzo1x_999_compress_level(const lzo_bytep src, lzo_uint  src_len,
                          lzo_bytep dst, lzo_uintp dst_len,
                          lzo_voidp wrkmem,
                          const lzo_bytep dict, lzo_uint dict_len,
                          lzo_callback_p cb,
-                                    int compression_level );
+                         int compression_level);
 
 LZO_EXTERN(int)
-lzo1x_decompress_dict_safe ( const lzo_bytep src, lzo_uint  src_len,
+lzo1x_decompress_dict_safe(const lzo_bytep src, lzo_uint  src_len,
                            lzo_bytep dst, lzo_uintp dst_len,
                            lzo_voidp wrkmem /* NOT USED */,
-                             const lzo_bytep dict, lzo_uint dict_len );
+                           const lzo_bytep dict, lzo_uint dict_len);
 
 
 /***********************************************************************
@@ -149,9 +149,9 @@ lzo1x_decompress_dict_safe ( const lzo_bytep src, lzo_uint  src_len,
 ************************************************************************/
 
 LZO_EXTERN(int)
-lzo1x_optimize          (       lzo_bytep src, lzo_uint  src_len,
+lzo1x_optimize(lzo_bytep src, lzo_uint  src_len,
                lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem /* NOT USED */ );
+               lzo_voidp wrkmem /* NOT USED */);
 
 
 

extern/lzo/include/lzo/lzo1y.h

@@ -53,15 +53,15 @@ extern "C" {
 
 /* decompression */
 LZO_EXTERN(int)
-lzo1y_decompress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1y_decompress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem /* NOT USED */ );
+                 lzo_voidp wrkmem /* NOT USED */);
 
 /* safe decompression with overrun testing */
 LZO_EXTERN(int)
-lzo1y_decompress_safe   ( const lzo_bytep src, lzo_uint  src_len,
+lzo1y_decompress_safe(const lzo_bytep src, lzo_uint  src_len,
                       lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem /* NOT USED */ );
+                      lzo_voidp wrkmem /* NOT USED */);
 
 
 /***********************************************************************
@@ -69,9 +69,9 @@ lzo1y_decompress_safe   ( const lzo_bytep src, lzo_uint  src_len,
 ************************************************************************/
 
 LZO_EXTERN(int)
-lzo1y_1_compress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1y_1_compress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                 lzo_voidp wrkmem);
 
 
 /***********************************************************************
@@ -81,9 +81,9 @@ lzo1y_1_compress        ( const lzo_bytep src, lzo_uint  src_len,
 #define LZO1Y_999_MEM_COMPRESS  ((lzo_uint32_t) (14 * 16384L * sizeof(short)))
 
 LZO_EXTERN(int)
-lzo1y_999_compress      ( const lzo_bytep src, lzo_uint  src_len,
+lzo1y_999_compress(const lzo_bytep src, lzo_uint  src_len,
                    lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                   lzo_voidp wrkmem);
 
 
 
@@ -92,24 +92,24 @@ lzo1y_999_compress      ( const lzo_bytep src, lzo_uint  src_len,
 ************************************************************************/
 
 LZO_EXTERN(int)
-lzo1y_999_compress_dict     ( const lzo_bytep src, lzo_uint  src_len,
+lzo1y_999_compress_dict(const lzo_bytep src, lzo_uint  src_len,
                         lzo_bytep dst, lzo_uintp dst_len,
                         lzo_voidp wrkmem,
-                              const lzo_bytep dict, lzo_uint dict_len );
+                        const lzo_bytep dict, lzo_uint dict_len);
 
 LZO_EXTERN(int)
-lzo1y_999_compress_level    ( const lzo_bytep src, lzo_uint  src_len,
+lzo1y_999_compress_level(const lzo_bytep src, lzo_uint  src_len,
                          lzo_bytep dst, lzo_uintp dst_len,
                          lzo_voidp wrkmem,
                          const lzo_bytep dict, lzo_uint dict_len,
                          lzo_callback_p cb,
-                                    int compression_level );
+                         int compression_level);
 
 LZO_EXTERN(int)
-lzo1y_decompress_dict_safe ( const lzo_bytep src, lzo_uint  src_len,
+lzo1y_decompress_dict_safe(const lzo_bytep src, lzo_uint  src_len,
                            lzo_bytep dst, lzo_uintp dst_len,
                            lzo_voidp wrkmem /* NOT USED */,
-                             const lzo_bytep dict, lzo_uint dict_len );
+                           const lzo_bytep dict, lzo_uint dict_len);
 
 
 /***********************************************************************
@@ -117,9 +117,9 @@ lzo1y_decompress_dict_safe ( const lzo_bytep src, lzo_uint  src_len,
 ************************************************************************/
 
 LZO_EXTERN(int)
-lzo1y_optimize          (       lzo_bytep src, lzo_uint  src_len,
+lzo1y_optimize(lzo_bytep src, lzo_uint  src_len,
                lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem /* NOT USED */ );
+               lzo_voidp wrkmem /* NOT USED */);
 
 
 

extern/lzo/include/lzo/lzo1z.h

@@ -51,15 +51,15 @@ extern "C" {
 
 /* decompression */
 LZO_EXTERN(int)
-lzo1z_decompress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo1z_decompress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem /* NOT USED */ );
+                 lzo_voidp wrkmem /* NOT USED */);
 
 /* safe decompression with overrun testing */
 LZO_EXTERN(int)
-lzo1z_decompress_safe   ( const lzo_bytep src, lzo_uint  src_len,
+lzo1z_decompress_safe(const lzo_bytep src, lzo_uint  src_len,
                       lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem /* NOT USED */ );
+                      lzo_voidp wrkmem /* NOT USED */);
 
 
 /***********************************************************************
@@ -69,9 +69,9 @@ lzo1z_decompress_safe   ( const lzo_bytep src, lzo_uint  src_len,
 #define LZO1Z_999_MEM_COMPRESS  ((lzo_uint32_t) (14 * 16384L * sizeof(short)))
 
 LZO_EXTERN(int)
-lzo1z_999_compress      ( const lzo_bytep src, lzo_uint  src_len,
+lzo1z_999_compress(const lzo_bytep src, lzo_uint  src_len,
                    lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                   lzo_voidp wrkmem);
 
 
 /***********************************************************************
@@ -79,24 +79,24 @@ lzo1z_999_compress      ( const lzo_bytep src, lzo_uint  src_len,
 ************************************************************************/
 
 LZO_EXTERN(int)
-lzo1z_999_compress_dict     ( const lzo_bytep src, lzo_uint  src_len,
+lzo1z_999_compress_dict(const lzo_bytep src, lzo_uint  src_len,
                         lzo_bytep dst, lzo_uintp dst_len,
                         lzo_voidp wrkmem,
-                              const lzo_bytep dict, lzo_uint dict_len );
+                        const lzo_bytep dict, lzo_uint dict_len);
 
 LZO_EXTERN(int)
-lzo1z_999_compress_level    ( const lzo_bytep src, lzo_uint  src_len,
+lzo1z_999_compress_level(const lzo_bytep src, lzo_uint  src_len,
                          lzo_bytep dst, lzo_uintp dst_len,
                          lzo_voidp wrkmem,
                          const lzo_bytep dict, lzo_uint dict_len,
                          lzo_callback_p cb,
-                                    int compression_level );
+                         int compression_level);
 
 LZO_EXTERN(int)
-lzo1z_decompress_dict_safe ( const lzo_bytep src, lzo_uint  src_len,
+lzo1z_decompress_dict_safe(const lzo_bytep src, lzo_uint  src_len,
                            lzo_bytep dst, lzo_uintp dst_len,
                            lzo_voidp wrkmem /* NOT USED */,
-                             const lzo_bytep dict, lzo_uint dict_len );
+                           const lzo_bytep dict, lzo_uint dict_len);
 
 
 #ifdef __cplusplus

extern/lzo/include/lzo/lzo2a.h

@@ -46,15 +46,15 @@ extern "C" {
 
 /* decompression */
 LZO_EXTERN(int)
-lzo2a_decompress        ( const lzo_bytep src, lzo_uint  src_len,
+lzo2a_decompress(const lzo_bytep src, lzo_uint  src_len,
                  lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem /* NOT USED */ );
+                 lzo_voidp wrkmem /* NOT USED */);
 
 /* safe decompression with overrun testing */
 LZO_EXTERN(int)
-lzo2a_decompress_safe   ( const lzo_bytep src, lzo_uint  src_len,
+lzo2a_decompress_safe(const lzo_bytep src, lzo_uint  src_len,
                       lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem /* NOT USED */ );
+                      lzo_voidp wrkmem /* NOT USED */);
 
 
 /***********************************************************************
@@ -64,9 +64,9 @@ lzo2a_decompress_safe   ( const lzo_bytep src, lzo_uint  src_len,
 #define LZO2A_999_MEM_COMPRESS  ((lzo_uint32_t) (8 * 16384L * sizeof(short)))
 
 LZO_EXTERN(int)
-lzo2a_999_compress      ( const lzo_bytep src, lzo_uint  src_len,
+lzo2a_999_compress(const lzo_bytep src, lzo_uint  src_len,
                    lzo_bytep dst, lzo_uintp dst_len,
-                                lzo_voidp wrkmem );
+                   lzo_voidp wrkmem);
 
 
 

extern/lzo/include/lzo/lzo_asm.h

@@ -56,54 +56,54 @@ extern "C" {
 ************************************************************************/
 
 LZO_EXTERN(int) lzo1c_decompress_asm
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem);
 LZO_EXTERN(int) lzo1c_decompress_asm_safe
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem);
 
 LZO_EXTERN(int) lzo1f_decompress_asm_fast
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem);
 LZO_EXTERN(int) lzo1f_decompress_asm_fast_safe
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem);
 
 LZO_EXTERN(int) lzo1x_decompress_asm
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem);
 LZO_EXTERN(int) lzo1x_decompress_asm_safe
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem);
 LZO_EXTERN(int) lzo1x_decompress_asm_fast
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem);
 LZO_EXTERN(int) lzo1x_decompress_asm_fast_safe
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem);
 
 LZO_EXTERN(int) lzo1y_decompress_asm
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem);
 LZO_EXTERN(int) lzo1y_decompress_asm_safe
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem);
 LZO_EXTERN(int) lzo1y_decompress_asm_fast
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem);
 LZO_EXTERN(int) lzo1y_decompress_asm_fast_safe
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem);
 
@@ -122,10 +122,10 @@ LZO_EXTERN(lzo_uint32_t)
 lzo_crc32_asm_small(lzo_uint32_t c, const lzo_bytep buf, lzo_uint len);
 
 LZO_EXTERN(int)
-lzo_cpuid_asm(lzo_uint32_tp /* lzo_uint32_t info[16] */ );
+lzo_cpuid_asm(lzo_uint32_tp /* lzo_uint32_t info[16] */);
 
 LZO_EXTERN(lzo_uint32_t)
-lzo_rdtsc_asm(lzo_uint32_tp /* lzo_uint32_t ticks[2] */ );
+lzo_rdtsc_asm(lzo_uint32_tp /* lzo_uint32_t ticks[2] */);
 
 #endif
 

extern/lzo/include/lzo/lzoconf.h

@@ -92,12 +92,12 @@ extern "C" {
 #if !defined(LZO_UINT_MAX)
 #  if (LZO_ABI_LLP64)
 #    if (LZO_OS_WIN64)
-     typedef unsigned __int64   lzo_uint;
-     typedef __int64            lzo_int;
+typedef unsigned __int64   lzo_uint;
+typedef __int64            lzo_int;
 #    define LZO_TYPEOF_LZO_INT  LZO_TYPEOF___INT64
 #    else
-     typedef lzo_ullong_t       lzo_uint;
-     typedef lzo_llong_t        lzo_int;
+typedef lzo_ullong_t       lzo_uint;
+typedef lzo_llong_t        lzo_int;
 #    define LZO_TYPEOF_LZO_INT  LZO_TYPEOF_LONG_LONG
 #    endif
 #    define LZO_SIZEOF_LZO_INT  8
@@ -105,16 +105,16 @@ extern "C" {
 #    define LZO_INT_MAX         9223372036854775807LL
 #    define LZO_INT_MIN         (-1LL - LZO_INT_MAX)
 #  elif (LZO_ABI_IP32L64) /* MIPS R5900 */
-     typedef unsigned int       lzo_uint;
-     typedef int                lzo_int;
+typedef unsigned int       lzo_uint;
+typedef int                lzo_int;
 #    define LZO_SIZEOF_LZO_INT  LZO_SIZEOF_INT
 #    define LZO_TYPEOF_LZO_INT  LZO_TYPEOF_INT
 #    define LZO_UINT_MAX        UINT_MAX
 #    define LZO_INT_MAX         INT_MAX
 #    define LZO_INT_MIN         INT_MIN
 #  elif (ULONG_MAX >= LZO_0xffffffffL)
-     typedef unsigned long      lzo_uint;
-     typedef long               lzo_int;
+typedef unsigned long      lzo_uint;
+typedef long               lzo_int;
 #    define LZO_SIZEOF_LZO_INT  LZO_SIZEOF_LONG
 #    define LZO_TYPEOF_LZO_INT  LZO_TYPEOF_LONG
 #    define LZO_UINT_MAX        ULONG_MAX
@@ -191,11 +191,11 @@ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint) >= 4)
 LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint) == sizeof(size_t))
 LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint) == sizeof(ptrdiff_t))
 LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint) == sizeof(lzo_uintptr_t))
-LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(void *)   == sizeof(lzo_uintptr_t))
-LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(char *)   == sizeof(lzo_uintptr_t))
-LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(long *)   == sizeof(lzo_uintptr_t))
-LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(void *)   == sizeof(lzo_voidp))
-LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(char *)   == sizeof(lzo_bytep))
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(void*)   == sizeof(lzo_uintptr_t))
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(char*)   == sizeof(lzo_uintptr_t))
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(long*)   == sizeof(lzo_uintptr_t))
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(void*)   == sizeof(lzo_voidp))
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(char*)   == sizeof(lzo_bytep))
 
 
 /***********************************************************************
@@ -237,31 +237,31 @@ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(char *)   == sizeof(lzo_bytep))
 
 /* function types */
 typedef int
-(__LZO_CDECL *lzo_compress_t)   ( const lzo_bytep src, lzo_uint  src_len,
+(__LZO_CDECL* lzo_compress_t)(const lzo_bytep src, lzo_uint  src_len,
                               lzo_bytep dst, lzo_uintp dst_len,
-                                        lzo_voidp wrkmem );
+                              lzo_voidp wrkmem);
 
 typedef int
-(__LZO_CDECL *lzo_decompress_t) ( const lzo_bytep src, lzo_uint  src_len,
+(__LZO_CDECL* lzo_decompress_t)(const lzo_bytep src, lzo_uint  src_len,
                                 lzo_bytep dst, lzo_uintp dst_len,
-                                        lzo_voidp wrkmem );
+                                lzo_voidp wrkmem);
 
 typedef int
-(__LZO_CDECL *lzo_optimize_t)   (       lzo_bytep src, lzo_uint  src_len,
+(__LZO_CDECL* lzo_optimize_t)(lzo_bytep src, lzo_uint  src_len,
                               lzo_bytep dst, lzo_uintp dst_len,
-                                        lzo_voidp wrkmem );
+                              lzo_voidp wrkmem);
 
 typedef int
-(__LZO_CDECL *lzo_compress_dict_t)(const lzo_bytep src, lzo_uint  src_len,
+(__LZO_CDECL* lzo_compress_dict_t)(const lzo_bytep src, lzo_uint  src_len,
                                    lzo_bytep dst, lzo_uintp dst_len,
                                    lzo_voidp wrkmem,
-                                   const lzo_bytep dict, lzo_uint dict_len );
+                                   const lzo_bytep dict, lzo_uint dict_len);
 
 typedef int
-(__LZO_CDECL *lzo_decompress_dict_t)(const lzo_bytep src, lzo_uint  src_len,
+(__LZO_CDECL* lzo_decompress_dict_t)(const lzo_bytep src, lzo_uint  src_len,
                                      lzo_bytep dst, lzo_uintp dst_len,
                                      lzo_voidp wrkmem,
-                                     const lzo_bytep dict, lzo_uint dict_len );
+                                     const lzo_bytep dict, lzo_uint dict_len);
 
 
 /* Callback interface. Currently only the progress indicator ("nprogress")
@@ -272,14 +272,14 @@ typedef struct lzo_callback_t lzo_callback_t;
 #define lzo_callback_p lzo_callback_t __LZO_MMODEL *
 
 /* malloc & free function types */
-typedef lzo_voidp (__LZO_CDECL *lzo_alloc_func_t)
-    (lzo_callback_p self, lzo_uint items, lzo_uint size);
-typedef void      (__LZO_CDECL *lzo_free_func_t)
-    (lzo_callback_p self, lzo_voidp ptr);
+typedef lzo_voidp(__LZO_CDECL* lzo_alloc_func_t)
+(lzo_callback_p self, lzo_uint items, lzo_uint size);
+typedef void (__LZO_CDECL* lzo_free_func_t)
+(lzo_callback_p self, lzo_voidp ptr);
 
 /* a progress indicator callback function */
-typedef void (__LZO_CDECL *lzo_progress_func_t)
-    (lzo_callback_p, lzo_uint, lzo_uint, int);
+typedef void (__LZO_CDECL* lzo_progress_func_t)
+(lzo_callback_p, lzo_uint, lzo_uint, int);
 
 struct lzo_callback_t
 {
@@ -337,38 +337,47 @@ struct lzo_callback_t
     (int)sizeof(long),(int)sizeof(lzo_uint32_t),(int)sizeof(lzo_uint),\
     (int)lzo_sizeof_dict_t,(int)sizeof(char *),(int)sizeof(lzo_voidp),\
     (int)sizeof(lzo_callback_t))
-LZO_EXTERN(int) __lzo_init_v2(unsigned,int,int,int,int,int,int,int,int,int);
+LZO_EXTERN(int) __lzo_init_v2(unsigned, int, int, int, int, int, int, int, int, int);
 
 /* version functions (useful for shared libraries) */
 LZO_EXTERN(unsigned) lzo_version(void);
-LZO_EXTERN(const char *) lzo_version_string(void);
-LZO_EXTERN(const char *) lzo_version_date(void);
+LZO_EXTERN(const char*) lzo_version_string(void);
+LZO_EXTERN(const char*) lzo_version_date(void);
 LZO_EXTERN(const lzo_charp) _lzo_version_string(void);
 LZO_EXTERN(const lzo_charp) _lzo_version_date(void);
 
 /* string functions */
 LZO_EXTERN(int)
-    lzo_memcmp(const lzo_voidp a, const lzo_voidp b, lzo_uint len);
+lzo_memcmp(const lzo_voidp a, const lzo_voidp b, lzo_uint len);
 LZO_EXTERN(lzo_voidp)
-    lzo_memcpy(lzo_voidp dst, const lzo_voidp src, lzo_uint len);
+lzo_memcpy(lzo_voidp dst, const lzo_voidp src, lzo_uint len);
 LZO_EXTERN(lzo_voidp)
-    lzo_memmove(lzo_voidp dst, const lzo_voidp src, lzo_uint len);
+lzo_memmove(lzo_voidp dst, const lzo_voidp src, lzo_uint len);
 LZO_EXTERN(lzo_voidp)
-    lzo_memset(lzo_voidp buf, int c, lzo_uint len);
+lzo_memset(lzo_voidp buf, int c, lzo_uint len);
 
 /* checksum functions */
 LZO_EXTERN(lzo_uint32_t)
-    lzo_adler32(lzo_uint32_t c, const lzo_bytep buf, lzo_uint len);
+lzo_adler32(lzo_uint32_t c, const lzo_bytep buf, lzo_uint len);
 LZO_EXTERN(lzo_uint32_t)
-    lzo_crc32(lzo_uint32_t c, const lzo_bytep buf, lzo_uint len);
+lzo_crc32(lzo_uint32_t c, const lzo_bytep buf, lzo_uint len);
 LZO_EXTERN(const lzo_uint32_tp)
-    lzo_get_crc32_table(void);
+lzo_get_crc32_table(void);
 
 /* misc. */
 LZO_EXTERN(int) _lzo_config_check(void);
-typedef union {
-    lzo_voidp a00; lzo_bytep a01; lzo_uint a02; lzo_xint a03; lzo_uintptr_t a04;
-    void *a05; unsigned char *a06; unsigned long a07; size_t a08; ptrdiff_t a09;
+typedef union
+{
+    lzo_voidp a00;
+    lzo_bytep a01;
+    lzo_uint a02;
+    lzo_xint a03;
+    lzo_uintptr_t a04;
+    void* a05;
+    unsigned char* a06;
+    unsigned long a07;
+    size_t a08;
+    ptrdiff_t a09;
 #if defined(lzo_int64_t)
     lzo_uint64_t a10;
 #endif

extern/lzo/include/lzo/lzodefs.h

@@ -1114,21 +1114,21 @@
 extern "C" {
 #endif
 #if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0200))
-   extern void __near __cdecl _AHSHIFT(void);
+extern void __near __cdecl _AHSHIFT(void);
 #  define LZO_MM_AHSHIFT      ((unsigned) _AHSHIFT)
 #elif (LZO_CC_DMC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC)
-   extern void __near __cdecl _AHSHIFT(void);
+extern void __near __cdecl _AHSHIFT(void);
 #  define LZO_MM_AHSHIFT      ((unsigned) _AHSHIFT)
 #elif (LZO_CC_MSC || LZO_CC_TOPSPEEDC)
-   extern void __near __cdecl _AHSHIFT(void);
+extern void __near __cdecl _AHSHIFT(void);
 #  define LZO_MM_AHSHIFT      ((unsigned) _AHSHIFT)
 #elif (LZO_CC_TURBOC && (__TURBOC__ >= 0x0295))
-   extern void __near __cdecl _AHSHIFT(void);
+extern void __near __cdecl _AHSHIFT(void);
 #  define LZO_MM_AHSHIFT      ((unsigned) _AHSHIFT)
 #elif ((LZO_CC_AZTECC || LZO_CC_PACIFICC || LZO_CC_TURBOC) && LZO_OS_DOS16)
 #  define LZO_MM_AHSHIFT      12
 #elif (LZO_CC_WATCOMC)
-   extern unsigned char _HShift;
+extern unsigned char _HShift;
 #  define LZO_MM_AHSHIFT      ((unsigned) _HShift)
 #else
 #  error "FIXME - implement LZO_MM_AHSHIFT"
@@ -2317,7 +2317,7 @@ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(long) == 8)
 #if !defined(LZO_SIZEOF_VOID_P)
 #  define LZO_SIZEOF_VOID_P         LZO_SIZEOF_LONG
 #endif
-LZO_COMPILE_TIME_ASSERT_HEADER(LZO_SIZEOF_VOID_P == sizeof(void *))
+LZO_COMPILE_TIME_ASSERT_HEADER(LZO_SIZEOF_VOID_P == sizeof(void*))
 #if !defined(LZO_SIZEOF_SIZE_T)
 #if (LZO_ARCH_I086 || LZO_ARCH_M16C)
 #  define LZO_SIZEOF_SIZE_T         2
@@ -2741,8 +2741,8 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__;
 #  define lzo_uint16e_t             unsigned short int
 #  define LZO_TYPEOF_LZO_INT16E_T   LZO_TYPEOF_SHORT
 #elif 1 && !(LZO_CFG_TYPE_NO_MODE_HI) && (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x025f00ul) || LZO_CC_LLVM)
-   typedef int lzo_int16e_hi_t__ __attribute__((__mode__(__HI__)));
-   typedef unsigned int lzo_uint16e_hi_t__ __attribute__((__mode__(__HI__)));
+typedef int lzo_int16e_hi_t__ __attribute__((__mode__(__HI__)));
+typedef unsigned int lzo_uint16e_hi_t__ __attribute__((__mode__(__HI__)));
 #  define lzo_int16e_t              lzo_int16e_hi_t__
 #  define lzo_uint16e_t             lzo_uint16e_hi_t__
 #  define LZO_TYPEOF_LZO_INT16E_T   LZO_TYPEOF___MODE_HI
@@ -2755,8 +2755,8 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__;
 #endif
 #if defined(lzo_int16e_t)
 #  define LZO_SIZEOF_LZO_INT16E_T   2
-   LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int16e_t) == 2)
-   LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int16e_t) == LZO_SIZEOF_LZO_INT16E_T)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int16e_t) == 2)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int16e_t) == LZO_SIZEOF_LZO_INT16E_T)
 #endif
 #if !defined(lzo_int32e_t)
 #if (LZO_SIZEOF_LONG == 4)
@@ -2776,14 +2776,14 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__;
 #  define lzo_uint32e_t             lzo_ullong_t
 #  define LZO_TYPEOF_LZO_INT32E_T   LZO_TYPEOF_LONG_LONG
 #elif 1 && !(LZO_CFG_TYPE_NO_MODE_SI) && (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x025f00ul) || LZO_CC_LLVM) && (__INT_MAX__+0 > 2147483647L)
-   typedef int lzo_int32e_si_t__ __attribute__((__mode__(__SI__)));
-   typedef unsigned int lzo_uint32e_si_t__ __attribute__((__mode__(__SI__)));
+typedef int lzo_int32e_si_t__ __attribute__((__mode__(__SI__)));
+typedef unsigned int lzo_uint32e_si_t__ __attribute__((__mode__(__SI__)));
 #  define lzo_int32e_t              lzo_int32e_si_t__
 #  define lzo_uint32e_t             lzo_uint32e_si_t__
 #  define LZO_TYPEOF_LZO_INT32E_T   LZO_TYPEOF___MODE_SI
 #elif 1 && !(LZO_CFG_TYPE_NO_MODE_SI) && (LZO_CC_GNUC >= 0x025f00ul) && defined(__AVR__) && (__LONG_MAX__+0 == 32767L)
-   typedef int lzo_int32e_si_t__ __attribute__((__mode__(__SI__)));
-   typedef unsigned int lzo_uint32e_si_t__ __attribute__((__mode__(__SI__)));
+typedef int lzo_int32e_si_t__ __attribute__((__mode__(__SI__)));
+typedef unsigned int lzo_uint32e_si_t__ __attribute__((__mode__(__SI__)));
 #  define lzo_int32e_t              lzo_int32e_si_t__
 #  define lzo_uint32e_t             lzo_uint32e_si_t__
 #  define LZO_INT32_C(c)            (c##LL)
@@ -2798,8 +2798,8 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__;
 #endif
 #if defined(lzo_int32e_t)
 #  define LZO_SIZEOF_LZO_INT32E_T   4
-   LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32e_t) == 4)
-   LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32e_t) == LZO_SIZEOF_LZO_INT32E_T)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32e_t) == 4)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32e_t) == LZO_SIZEOF_LZO_INT32E_T)
 #endif
 #if !defined(lzo_int64e_t)
 #if (LZO_SIZEOF___INT64 == 8)
@@ -2845,8 +2845,8 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__;
 #endif
 #if defined(lzo_int64e_t)
 #  define LZO_SIZEOF_LZO_INT64E_T   8
-   LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64e_t) == 8)
-   LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64e_t) == LZO_SIZEOF_LZO_INT64E_T)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64e_t) == 8)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64e_t) == LZO_SIZEOF_LZO_INT64E_T)
 #endif
 #if !defined(lzo_int32l_t)
 #if defined(lzo_int32e_t)
@@ -2869,8 +2869,8 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__;
 #endif
 #endif
 #if 1
-   LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32l_t) >= 4)
-   LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32l_t) == LZO_SIZEOF_LZO_INT32L_T)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32l_t) >= 4)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32l_t) == LZO_SIZEOF_LZO_INT32L_T)
 #endif
 #if !defined(lzo_int64l_t)
 #if defined(lzo_int64e_t)
@@ -2882,8 +2882,8 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__;
 #endif
 #endif
 #if defined(lzo_int64l_t)
-   LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64l_t) >= 8)
-   LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64l_t) == LZO_SIZEOF_LZO_INT64L_T)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64l_t) >= 8)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64l_t) == LZO_SIZEOF_LZO_INT64L_T)
 #endif
 #if !defined(lzo_int32f_t)
 #if (LZO_SIZEOF_SIZE_T >= 8)
@@ -2899,8 +2899,8 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__;
 #endif
 #endif
 #if 1
-   LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32f_t) >= 4)
-   LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32f_t) == LZO_SIZEOF_LZO_INT32F_T)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32f_t) >= 4)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32f_t) == LZO_SIZEOF_LZO_INT32F_T)
 #endif
 #if !defined(lzo_int64f_t)
 #if defined(lzo_int64l_t)
@@ -2912,21 +2912,21 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__;
 #endif
 #endif
 #if defined(lzo_int64f_t)
-   LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64f_t) >= 8)
-   LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64f_t) == LZO_SIZEOF_LZO_INT64F_T)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64f_t) >= 8)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64f_t) == LZO_SIZEOF_LZO_INT64F_T)
 #endif
 #if !defined(lzo_intptr_t)
 #if 1 && (LZO_OS_OS400 && (LZO_SIZEOF_VOID_P == 16))
 #  define __LZO_INTPTR_T_IS_POINTER 1
-   typedef char *                   lzo_intptr_t;
-   typedef char *                   lzo_uintptr_t;
+typedef char*                    lzo_intptr_t;
+typedef char*                    lzo_uintptr_t;
 #  define lzo_intptr_t              lzo_intptr_t
 #  define lzo_uintptr_t             lzo_uintptr_t
 #  define LZO_SIZEOF_LZO_INTPTR_T   LZO_SIZEOF_VOID_P
 #  define LZO_TYPEOF_LZO_INTPTR_T   LZO_TYPEOF_CHAR_P
 #elif (LZO_CC_MSC && (_MSC_VER >= 1300) && (LZO_SIZEOF_VOID_P == 4) && (LZO_SIZEOF_INT == 4))
-   typedef __w64 int                lzo_intptr_t;
-   typedef __w64 unsigned int       lzo_uintptr_t;
+typedef __w64 int                lzo_intptr_t;
+typedef __w64 unsigned int       lzo_uintptr_t;
 #  define lzo_intptr_t              lzo_intptr_t
 #  define lzo_uintptr_t             lzo_uintptr_t
 #  define LZO_SIZEOF_LZO_INTPTR_T   LZO_SIZEOF_INT
@@ -2956,8 +2956,8 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__;
 #endif
 #endif
 #if 1
-    LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_intptr_t) >= sizeof(void *))
-    LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_intptr_t) == sizeof(lzo_uintptr_t))
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_intptr_t) >= sizeof(void*))
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_intptr_t) == sizeof(lzo_uintptr_t))
 #endif
 #if !defined(lzo_word_t)
 #if defined(LZO_WORDSIZE) && (LZO_WORDSIZE+0 > 0)
@@ -2993,8 +2993,8 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__;
 #  define LZO_TYPEOF_LZO_WORD_T     LZO_SIZEOF_LZO_INT64L_T
 #elif (LZO_ARCH_SPU) && (LZO_CC_GNUC)
 #if 0
-   typedef unsigned lzo_word_t  __attribute__((__mode__(__V16QI__)));
-   typedef int      lzo_sword_t __attribute__((__mode__(__V16QI__)));
+typedef unsigned lzo_word_t  __attribute__((__mode__(__V16QI__)));
+typedef int      lzo_sword_t __attribute__((__mode__(__V16QI__)));
 #  define lzo_word_t                lzo_word_t
 #  define lzo_sword_t               lzo_sword_t
 #  define LZO_SIZEOF_LZO_WORD_T     16
@@ -3006,8 +3006,8 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__;
 #endif
 #endif
 #if 1 && defined(lzo_word_t)
-    LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_word_t)  == LZO_WORDSIZE)
-    LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_sword_t) == LZO_WORDSIZE)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_word_t)  == LZO_WORDSIZE)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_sword_t) == LZO_WORDSIZE)
 #endif
 #if 1
 #define lzo_int8_t                  signed char

extern/lzo/lzo.pri

@@ -1,78 +0,0 @@
-SOURCES += \
-    $$PWD/src/lzo1.c \
-    $$PWD/src/lzo1_99.c \
-    $$PWD/src/lzo1a.c \
-    $$PWD/src/lzo1a_99.c \
-    $$PWD/src/lzo1b_1.c \
-    $$PWD/src/lzo1b_2.c \
-    $$PWD/src/lzo1b_3.c \
-    $$PWD/src/lzo1b_4.c \
-    $$PWD/src/lzo1b_5.c \
-    $$PWD/src/lzo1b_6.c \
-    $$PWD/src/lzo1b_7.c \
-    $$PWD/src/lzo1b_8.c \
-    $$PWD/src/lzo1b_9.c \
-    $$PWD/src/lzo1b_99.c \
-    $$PWD/src/lzo1b_9x.c \
-    $$PWD/src/lzo1b_cc.c \
-    $$PWD/src/lzo1b_d1.c \
-    $$PWD/src/lzo1b_d2.c \
-    $$PWD/src/lzo1b_rr.c \
-    $$PWD/src/lzo1b_xx.c \
-    $$PWD/src/lzo1c_1.c \
-    $$PWD/src/lzo1c_2.c \
-    $$PWD/src/lzo1c_3.c \
-    $$PWD/src/lzo1c_4.c \
-    $$PWD/src/lzo1c_5.c \
-    $$PWD/src/lzo1c_6.c \
-    $$PWD/src/lzo1c_7.c \
-    $$PWD/src/lzo1c_8.c \
-    $$PWD/src/lzo1c_9.c \
-    $$PWD/src/lzo1c_99.c \
-    $$PWD/src/lzo1c_9x.c \
-    $$PWD/src/lzo1c_cc.c \
-    $$PWD/src/lzo1c_d1.c \
-    $$PWD/src/lzo1c_d2.c \
-    $$PWD/src/lzo1c_rr.c \
-    $$PWD/src/lzo1c_xx.c \
-    $$PWD/src/lzo1f_1.c \
-    $$PWD/src/lzo1f_9x.c \
-    $$PWD/src/lzo1f_d1.c \
-    $$PWD/src/lzo1f_d2.c \
-    $$PWD/src/lzo1x_1.c \
-    $$PWD/src/lzo1x_1k.c \
-    $$PWD/src/lzo1x_1l.c \
-    $$PWD/src/lzo1x_1o.c \
-    $$PWD/src/lzo1x_9x.c \
-    $$PWD/src/lzo1x_d1.c \
-    $$PWD/src/lzo1x_d2.c \
-    $$PWD/src/lzo1x_d3.c \
-    $$PWD/src/lzo1x_o.c \
-    $$PWD/src/lzo1y_1.c \
-    $$PWD/src/lzo1y_9x.c \
-    $$PWD/src/lzo1y_d1.c \
-    $$PWD/src/lzo1y_d2.c \
-    $$PWD/src/lzo1y_d3.c \
-    $$PWD/src/lzo1y_o.c \
-    $$PWD/src/lzo1z_9x.c \
-    $$PWD/src/lzo1z_d1.c \
-    $$PWD/src/lzo1z_d2.c \
-    $$PWD/src/lzo1z_d3.c \
-    $$PWD/src/lzo2a_9x.c \
-    $$PWD/src/lzo2a_d1.c \
-    $$PWD/src/lzo2a_d2.c \
-    $$PWD/src/lzo_crc.c \
-    $$PWD/src/lzo_init.c \
-    $$PWD/src/lzo_ptr.c \
-    $$PWD/src/lzo_str.c \
-    $$PWD/src/lzo_util.c
-    
-HEADERS += \
-    $$PWD/include/lzo/lzo1.h \
-    $$PWD/include/lzo/lzo1x.h \
-    $$PWD/include/lzo/lzoconf.h \
-    $$PWD/include/lzo/lzodefs.h \
-    $$PWD/include/lzo/lzoutil.h
-
-INCLUDEPATH += $$PWD/include
-    

extern/lzo/src/compr1b.h

@@ -57,11 +57,11 @@
 const lzo_compress_t LZO_COMPRESS_FUNC = do_compress;
 
 LZO_PUBLIC(int)
-LZO_COMPRESS ( const lzo_bytep in,  lzo_uint  in_len,
+LZO_COMPRESS(const lzo_bytep in,  lzo_uint  in_len,
              lzo_bytep out, lzo_uintp out_len,
-                     lzo_voidp wrkmem )
+             lzo_voidp wrkmem)
 {
-    return _lzo1b_do_compress(in,in_len,out,out_len,wrkmem,do_compress);
+    return _lzo1b_do_compress(in, in_len, out, out_len, wrkmem, do_compress);
 }
 
 

extern/lzo/src/compr1c.h

@@ -57,11 +57,11 @@
 const lzo_compress_t LZO_COMPRESS_FUNC = do_compress;
 
 LZO_PUBLIC(int)
-LZO_COMPRESS ( const lzo_bytep in,  lzo_uint  in_len,
+LZO_COMPRESS(const lzo_bytep in,  lzo_uint  in_len,
              lzo_bytep out, lzo_uintp out_len,
-                     lzo_voidp wrkmem )
+             lzo_voidp wrkmem)
 {
-    return _lzo1c_do_compress(in,in_len,out,out_len,wrkmem,do_compress);
+    return _lzo1c_do_compress(in, in_len, out, out_len, wrkmem, do_compress);
 }
 
 

extern/lzo/src/lzo1.c

@@ -153,15 +153,17 @@ RBITS | MBITS  MIN  THR.  MSIZE  MAXS  MINL  MAXL   MAXO  R0MAX R0FAST
 // get algorithm info, return memory required for compression
 ************************************************************************/
 
-LZO_EXTERN(lzo_uint) lzo1_info ( int *rbits, int *clevel );
+LZO_EXTERN(lzo_uint) lzo1_info(int* rbits, int* clevel);
 
 LZO_PUBLIC(lzo_uint)
-lzo1_info ( int *rbits, int *clevel )
+lzo1_info(int* rbits, int* clevel)
 {
     if (rbits)
         *rbits = RBITS;
+
     if (clevel)
         *clevel = CLEVEL;
+
     return D_SIZE * lzo_sizeof(lzo_bytep);
 }
 
@@ -190,9 +192,9 @@ lzo1_info ( int *rbits, int *clevel )
 ************************************************************************/
 
 LZO_PUBLIC(int)
-lzo1_decompress  ( const lzo_bytep in , lzo_uint  in_len,
+lzo1_decompress(const lzo_bytep in , lzo_uint  in_len,
                 lzo_bytep out, lzo_uintp out_len,
-                         lzo_voidp wrkmem )
+                lzo_voidp wrkmem)
 {
     lzo_bytep op;
     const lzo_bytep ip;
@@ -203,6 +205,7 @@ lzo1_decompress  ( const lzo_bytep in , lzo_uint  in_len,
 
     op = out;
     ip = in;
+
     while (ip < ip_end)
     {
         t = *ip++;  /* get marker */
@@ -212,9 +215,11 @@ lzo1_decompress  ( const lzo_bytep in , lzo_uint  in_len,
             if (t == 0)             /* a R0 literal run */
             {
                 t = *ip++;
+
                 if (t >= R0FAST - R0MIN)            /* a long R0 run */
                 {
                     t -= R0FAST - R0MIN;
+
                     if (t == 0)
                         t = R0FAST;
                     else
@@ -224,23 +229,30 @@ lzo1_decompress  ( const lzo_bytep in , lzo_uint  in_len,
 #else
                         /* help the optimizer */
                         lzo_uint tt = 256;
-                        do tt <<= 1; while (--t > 0);
+
+                        do tt <<= 1;
+
+                        while (--t > 0);
+
                         t = tt;
 #endif
                     }
-                    MEMCPY8_DS(op,ip,t);
+
+                    MEMCPY8_DS(op, ip, t);
                     continue;
                 }
+
                 t += R0MIN;
             }
-            MEMCPY_DS(op,ip,t);
+
+            MEMCPY_DS(op, ip, t);
         }
         else                    /* a match */
         {
             lzo_uint tt;
             /* get match offset */
             const lzo_bytep m_pos = op - 1;
-            m_pos -= (lzo_uint)(t & OMASK) | (((lzo_uint) *ip++) << OBITS);
+            m_pos -= (lzo_uint)(t & OMASK) | (((lzo_uint) * ip++) << OBITS);
 
             /* get match len */
             if (t >= ((MSIZE - 1) << OBITS))                /* all m-bits set */
@@ -253,7 +265,7 @@ lzo1_decompress  ( const lzo_bytep in , lzo_uint  in_len,
             /* a half unrolled loop */
             *op++ = *m_pos++;
             *op++ = *m_pos++;
-            MEMCPY_DS(op,m_pos,tt);
+            MEMCPY_DS(op, m_pos, tt);
         }
     }
 
@@ -282,26 +294,33 @@ store_run(lzo_bytep op, const lzo_bytep ii, lzo_uint r_len)
     if (r_len >= 512)
     {
         unsigned r_bits = 7;        /* 256 << 7 == 32768 */
-        do {
+
+        do
+        {
             while (r_len >= (256u << r_bits))
             {
                 r_len -= (256u << r_bits);
-                *op++ = 0; *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits);
+                *op++ = 0;
+                *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits);
                 MEMCPY8_DS(op, ii, (256u << r_bits));
             }
-        } while (--r_bits > 0);
         }
+        while (--r_bits > 0);
+    }
+
     while (r_len >= R0FAST)
     {
         r_len -= R0FAST;
-        *op++ = 0; *op++ = R0FAST - R0MIN;
+        *op++ = 0;
+        *op++ = R0FAST - R0MIN;
         MEMCPY8_DS(op, ii, R0FAST);
     }
 
     if (r_len >= R0MIN)
     {
         /* code a short R0 run */
-        *op++ = 0; *op++ = LZO_BYTE(r_len - R0MIN);
+        *op++ = 0;
+        *op++ = LZO_BYTE(r_len - R0MIN);
         MEMCPY_DS(op, ii, r_len);
     }
     else if (r_len > 0)
@@ -326,9 +345,9 @@ store_run(lzo_bytep op, const lzo_bytep ii, lzo_uint r_len)
 ************************************************************************/
 
 static int
-do_compress    ( const lzo_bytep in , lzo_uint  in_len,
+do_compress(const lzo_bytep in , lzo_uint  in_len,
             lzo_bytep out, lzo_uintp out_len,
-                       lzo_voidp wrkmem )
+            lzo_voidp wrkmem)
 {
     const lzo_bytep ip;
 #if defined(__LZO_HASH_INCREMENTAL)
@@ -336,8 +355,8 @@ do_compress    ( const lzo_bytep in , lzo_uint  in_len,
 #endif
     lzo_bytep op;
     const lzo_bytep m_pos;
-    const lzo_bytep const ip_end = in+in_len - DVAL_LEN - MIN_MATCH_LONG;
-    const lzo_bytep const in_end = in+in_len - DVAL_LEN;
+    const lzo_bytep const ip_end = in + in_len - DVAL_LEN - MIN_MATCH_LONG;
+    const lzo_bytep const in_end = in + in_len - DVAL_LEN;
     const lzo_bytep ii;
     lzo_dict_p const dict = (lzo_dict_p) wrkmem;
 
@@ -348,46 +367,56 @@ do_compress    ( const lzo_bytep in , lzo_uint  in_len,
     op = out;
     ip = in;
     ii = ip;                /* point to start of literal run */
+
     if (in_len <= MIN_MATCH_LONG + DVAL_LEN + 1)
         goto the_end;
 
     /* init dictionary */
 #if (LZO_DETERMINISTIC)
-    BZERO8_PTR(wrkmem,sizeof(lzo_dict_t),D_SIZE);
+    BZERO8_PTR(wrkmem, sizeof(lzo_dict_t), D_SIZE);
 #endif
 
-    DVAL_FIRST(dv,ip);
-    UPDATE_D(dict,0,dv,ip,in);
+    DVAL_FIRST(dv, ip);
+    UPDATE_D(dict, 0, dv, ip, in);
     ip++;
-    DVAL_NEXT(dv,ip);
+    DVAL_NEXT(dv, ip);
 
-    do {
+    do
+    {
         LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, m_off, 0);
         lzo_uint dindex;
 
-        DINDEX1(dindex,ip);
-        GINDEX(m_pos,m_off,dict,dindex,in);
-        if (LZO_CHECK_MPOS(m_pos,m_off,in,ip,MAX_OFFSET))
+        DINDEX1(dindex, ip);
+        GINDEX(m_pos, m_off, dict, dindex, in);
+
+        if (LZO_CHECK_MPOS(m_pos, m_off, in, ip, MAX_OFFSET))
             goto literal;
+
         if (m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2])
             goto match;
-        DINDEX2(dindex,ip);
-        GINDEX(m_pos,m_off,dict,dindex,in);
-        if (LZO_CHECK_MPOS(m_pos,m_off,in,ip,MAX_OFFSET))
+
+        DINDEX2(dindex, ip);
+        GINDEX(m_pos, m_off, dict, dindex, in);
+
+        if (LZO_CHECK_MPOS(m_pos, m_off, in, ip, MAX_OFFSET))
             goto literal;
+
         if (m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2])
             goto match;
+
         goto literal;
 
 
 literal:
-        UPDATE_I(dict,0,dindex,ip,in);
+        UPDATE_I(dict, 0, dindex, ip, in);
+
         if (++ip >= ip_end)
             break;
+
         continue;
 
 match:
-        UPDATE_I(dict,0,dindex,ip,in);
+        UPDATE_I(dict, 0, dindex, ip, in);
 #if !defined(NDEBUG) && (LZO_DICT_USE_PTR)
         m_pos_sav = m_pos;
 #endif
@@ -397,11 +426,13 @@ match:
 #if !defined(NDEBUG) && !(LZO_DICT_USE_PTR)
             assert((m_pos_sav = ip - m_off) == (m_pos - 3));
 #endif
+
             /* 1) store the current literal run */
-            if (pd(ip,ii) > 0)
+            if (pd(ip, ii) > 0)
             {
-                lzo_uint t = pd(ip,ii);
+                lzo_uint t = pd(ip, ii);
 #if 1
+
                 /* OPTIMIZED: inline the copying of a short run */
                 if (t < R0MIN)
                 {
@@ -410,7 +441,7 @@ match:
                 }
                 else
 #endif
-                    op = store_run(op,ii,t);
+                    op = store_run(op, ii, t);
             }
 
             /* 2a) compute match len */
@@ -427,6 +458,7 @@ match:
 #define PS  *m_pos++ != *ip++
 
 #if (MIN_MATCH_LONG - MIN_MATCH == 2)                   /* MBITS == 2 */
+
             if (PS || PS)
 #elif (MIN_MATCH_LONG - MIN_MATCH == 6)                 /* MBITS == 3 */
             if (PS || PS || PS || PS || PS || PS)
@@ -445,15 +477,15 @@ match:
                 lzo_uint m_len;
 
                 /* 2b) code a short match */
-                    assert(pd(ip,m_pos) == m_off);
+                assert(pd(ip, m_pos) == m_off);
                 --ip;   /* ran one too far, point back to non-match */
                 m_len = pd(ip, ii);
                 assert(m_len >= MIN_MATCH_SHORT);
                 assert(m_len <= MAX_MATCH_SHORT);
                 assert(m_off > 0);
                 assert(m_off <= MAX_OFFSET);
-                    assert(ii-m_off == m_pos_sav);
-                    assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
+                assert(ii - m_off == m_pos_sav);
+                assert(lzo_memcmp(m_pos_sav, ii, m_len) == 0);
                 --m_off;
                 /* code short match len + low offset bits */
                 *op++ = LZO_BYTE(((m_len - THRESHOLD) << OBITS) |
@@ -471,13 +503,17 @@ match:
 #if (CLEVEL == 9) || (CLEVEL >= 7 && MBITS <= 4) || (CLEVEL >= 5 && MBITS <= 3)
                 /* Insert the whole match (ii+1)..(ip-1) into dictionary.  */
                 ++ii;
-                do {
-                    DVAL_NEXT(dv,ii);
-                    UPDATE_D(dict,0,dv,ii,in);
-                } while (++ii < ip);
-                DVAL_NEXT(dv,ii);
+
+                do
+                {
+                    DVAL_NEXT(dv, ii);
+                    UPDATE_D(dict, 0, dv, ii, in);
+                }
+                while (++ii < ip);
+
+                DVAL_NEXT(dv, ii);
                 assert(ii == ip);
-                DVAL_ASSERT(dv,ip);
+                DVAL_ASSERT(dv, ip);
 #elif (CLEVEL >= 3)
                 SI   DI DI   XI
 #elif (CLEVEL >= 2)
@@ -496,7 +532,7 @@ match:
                 assert(ip <= in_end);
                 assert(ii == ip - MIN_MATCH_LONG);
 
-                if (pd(in_end,ip) <= (MAX_MATCH_LONG - MIN_MATCH_LONG))
+                if (pd(in_end, ip) <= (MAX_MATCH_LONG - MIN_MATCH_LONG))
                     end = in_end;
                 else
                 {
@@ -506,6 +542,7 @@ match:
 
                 while (ip < end  &&  *m_pos == *ip)
                     m_pos++, ip++;
+
                 assert(ip <= in_end);
 
                 /* 2b) code the long match */
@@ -514,9 +551,9 @@ match:
                 assert(m_len <= MAX_MATCH_LONG);
                 assert(m_off > 0);
                 assert(m_off <= MAX_OFFSET);
-                    assert(ii-m_off == m_pos_sav);
-                    assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
-                    assert(pd(ip,m_pos) == m_off);
+                assert(ii - m_off == m_pos_sav);
+                assert(lzo_memcmp(m_pos_sav, ii, m_len) == 0);
+                assert(pd(ip, m_pos) == m_off);
                 --m_off;
                 /* code long match flag + low offset bits */
                 *op++ = LZO_BYTE(((MSIZE - 1) << OBITS) | (m_off & OMASK));
@@ -531,13 +568,17 @@ match:
                 /* Insert the whole match (ii+1)..(ip-1) into dictionary.  */
                 /* This is not recommended because it is slow. */
                 ++ii;
-                do {
-                    DVAL_NEXT(dv,ii);
-                    UPDATE_D(dict,0,dv,ii,in);
-                } while (++ii < ip);
-                DVAL_NEXT(dv,ii);
+
+                do
+                {
+                    DVAL_NEXT(dv, ii);
+                    UPDATE_D(dict, 0, dv, ii, in);
+                }
+                while (++ii < ip);
+
+                DVAL_NEXT(dv, ii);
                 assert(ii == ip);
-                DVAL_ASSERT(dv,ip);
+                DVAL_ASSERT(dv, ip);
 #elif (CLEVEL >= 8)
                 SI   DI DI DI DI DI DI DI DI   XI
 #elif (CLEVEL >= 7)
@@ -560,7 +601,8 @@ match:
             /* ii now points to the start of next literal run */
             assert(ii == ip);
         }
-    } while (ip < ip_end);
+    }
+    while (ip < ip_end);
 
 
 
@@ -569,6 +611,7 @@ the_end:
 
 
 #if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
+
     /* return -1 if op == out to indicate that we
      * couldn't compress and didn't copy anything.
      */
@@ -577,12 +620,13 @@ the_end:
         *out_len = 0;
         return LZO_E_NOT_COMPRESSIBLE;
     }
+
 #endif
 
 
     /* store the final literal run */
-    if (pd(in_end+DVAL_LEN,ii) > 0)
-        op = store_run(op,ii,pd(in_end+DVAL_LEN,ii));
+    if (pd(in_end + DVAL_LEN, ii) > 0)
+        op = store_run(op, ii, pd(in_end + DVAL_LEN, ii));
 
     *out_len = pd(op, out);
     return 0;               /* compression went ok */
@@ -594,9 +638,9 @@ the_end:
 ************************************************************************/
 
 LZO_PUBLIC(int)
-lzo1_compress ( const lzo_bytep in , lzo_uint  in_len,
+lzo1_compress(const lzo_bytep in , lzo_uint  in_len,
               lzo_bytep out, lzo_uintp out_len,
-                      lzo_voidp wrkmem )
+              lzo_voidp wrkmem)
 {
     int r = LZO_E_OK;
 
@@ -608,11 +652,11 @@ lzo1_compress ( const lzo_bytep in , lzo_uint  in_len,
 #if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
         r = LZO_E_NOT_COMPRESSIBLE;
 #else
-        *out_len = pd(store_run(out,in,in_len), out);
+        *out_len = pd(store_run(out, in, in_len), out);
 #endif
     }
     else
-        r = do_compress(in,in_len,out,out_len,wrkmem);
+        r = do_compress(in, in_len, out, out_len, wrkmem);
 
     return r;
 }

extern/lzo/src/lzo1_99.c

@@ -46,10 +46,10 @@
 ************************************************************************/
 
 static int
-_lzo1_do_compress ( const lzo_bytep in,  lzo_uint  in_len,
+_lzo1_do_compress(const lzo_bytep in,  lzo_uint  in_len,
                   lzo_bytep out, lzo_uintp out_len,
                   lzo_voidp wrkmem,
-                          lzo_compress_t func )
+                  lzo_compress_t func)
 {
     int r;
 
@@ -65,12 +65,12 @@ _lzo1_do_compress ( const lzo_bytep in,  lzo_uint  in_len,
         *out_len = 0;
         r = LZO_E_NOT_COMPRESSIBLE;
 #else
-        *out_len = pd(STORE_RUN(out,in,in_len), out);
+        *out_len = pd(STORE_RUN(out, in, in_len), out);
         r = (*out_len > in_len) ? LZO_E_OK : LZO_E_ERROR;
 #endif
     }
     else
-        r = func(in,in_len,out,out_len,wrkmem);
+        r = func(in, in_len, out, out_len, wrkmem);
 
     return r;
 }
@@ -105,11 +105,11 @@ _lzo1_do_compress ( const lzo_bytep in,  lzo_uint  in_len,
 ************************************************************************/
 
 LZO_PUBLIC(int)
-LZO_COMPRESS ( const lzo_bytep in,  lzo_uint  in_len,
+LZO_COMPRESS(const lzo_bytep in,  lzo_uint  in_len,
              lzo_bytep out, lzo_uintp out_len,
-                     lzo_voidp wrkmem )
+             lzo_voidp wrkmem)
 {
-    return _lzo1_do_compress(in,in_len,out,out_len,wrkmem,do_compress);
+    return _lzo1_do_compress(in, in_len, out, out_len, wrkmem, do_compress);
 }
 
 

extern/lzo/src/lzo1_d.ch

@@ -105,7 +105,7 @@
 
 
 #if !defined(LZO_EOF_CODE) && !defined(TEST_IP)
-   /* if we have no EOF code, we have to test for the end of the input */
+/* if we have no EOF code, we have to test for the end of the input */
 #  define TEST_IP               (ip < ip_end)
 #endif
 

extern/lzo/src/lzo1a.c

@@ -91,8 +91,8 @@
 
 
 #if (LZO_COLLECT_STATS)
-   static lzo1a_stats_t lzo_statistics;
-   lzo1a_stats_t *lzo1a_stats = &lzo_statistics;
+static lzo1a_stats_t lzo_statistics;
+lzo1a_stats_t* lzo1a_stats = &lzo_statistics;
 #  define lzo_stats lzo1a_stats
 #endif
 
@@ -101,15 +101,17 @@
 // get algorithm info, return memory required for compression
 ************************************************************************/
 
-LZO_EXTERN(lzo_uint) lzo1a_info ( int *rbits, int *clevel );
+LZO_EXTERN(lzo_uint) lzo1a_info(int* rbits, int* clevel);
 
 LZO_PUBLIC(lzo_uint)
-lzo1a_info ( int *rbits, int *clevel )
+lzo1a_info(int* rbits, int* clevel)
 {
     if (rbits)
         *rbits = RBITS;
+
     if (clevel)
         *clevel = CLEVEL;
+
     return D_SIZE * lzo_sizeof(lzo_bytep);
 }
 
@@ -121,9 +123,9 @@ lzo1a_info ( int *rbits, int *clevel )
 ************************************************************************/
 
 LZO_PUBLIC(int)
-lzo1a_decompress ( const lzo_bytep in , lzo_uint  in_len,
+lzo1a_decompress(const lzo_bytep in , lzo_uint  in_len,
                  lzo_bytep out, lzo_uintp out_len,
-                         lzo_voidp wrkmem )
+                 lzo_voidp wrkmem)
 {
     lzo_bytep op;
     const lzo_bytep ip;
@@ -135,6 +137,7 @@ lzo1a_decompress ( const lzo_bytep in , lzo_uint  in_len,
 
     op = out;
     ip = in;
+
     while (ip < ip_end)
     {
         t = *ip++;      /* get marker */
@@ -143,9 +146,11 @@ lzo1a_decompress ( const lzo_bytep in , lzo_uint  in_len,
         if (t == 0)             /* a R0 literal run */
         {
             t = *ip++;
+
             if (t >= R0FAST - R0MIN)            /* a long R0 run */
             {
                 t -= R0FAST - R0MIN;
+
                 if (t == 0)
                     t = R0FAST;
                 else
@@ -155,33 +160,41 @@ lzo1a_decompress ( const lzo_bytep in , lzo_uint  in_len,
 #else
                     /* help the optimizer */
                     lzo_uint tt = 256;
-                    do tt <<= 1; while (--t > 0);
+
+                    do tt <<= 1;
+
+                    while (--t > 0);
+
                     t = tt;
 #endif
                 }
-                MEMCPY8_DS(op,ip,t);
+
+                MEMCPY8_DS(op, ip, t);
                 continue;
             }
+
             t += R0MIN;
             goto literal;
         }
         else if (t < R0MIN)     /* a short literal run */
         {
 literal:
-            MEMCPY_DS(op,ip,t);
+            MEMCPY_DS(op, ip, t);
 
             /* after a literal a match must follow */
             while (ip < ip_end)
             {
                 t = *ip++;          /* get R1 marker */
+
                 if (t >= R0MIN)
                     goto match;
 
                 /* R1 match - a context sensitive 3 byte match + 1 byte literal */
                 assert((t & OMASK) == t);
                 m_pos = op - MIN_OFFSET;
-                m_pos -= t | (((lzo_uint) *ip++) << OBITS);
-                assert(m_pos >= out); assert(m_pos < op);
+                m_pos -= t | (((lzo_uint) * ip++) << OBITS);
+                assert(m_pos >= out);
+                assert(m_pos < op);
                 *op++ = m_pos[0];
                 *op++ = m_pos[1];
                 *op++ = m_pos[2];
@@ -193,8 +206,9 @@ literal:
 match:
             /* get match offset */
             m_pos = op - MIN_OFFSET;
-            m_pos -= (t & OMASK) | (((lzo_uint) *ip++) << OBITS);
-            assert(m_pos >= out); assert(m_pos < op);
+            m_pos -= (t & OMASK) | (((lzo_uint) * ip++) << OBITS);
+            assert(m_pos >= out);
+            assert(m_pos < op);
 
             /* get match len */
             if (t < ((MSIZE - 1) << OBITS))         /* a short match */
@@ -202,7 +216,7 @@ match:
                 t >>= OBITS;
                 *op++ = *m_pos++;
                 *op++ = *m_pos++;
-                MEMCPY_DS(op,m_pos,t);
+                MEMCPY_DS(op, m_pos, t);
             }
             else                                     /* a long match */
             {
@@ -213,13 +227,16 @@ match:
 #endif
                 *op++ = *m_pos++;
                 *op++ = *m_pos++;
-                MEMCPY_DS(op,m_pos,t);
+                MEMCPY_DS(op, m_pos, t);
 #if (LBITS < 8)
                 /* a very short literal following a long match */
                 t = ip[-1] >> LBITS;
+
                 if (t) do
                         *op++ = *ip++;
+
                     while (--t);
+
 #endif
             }
         }
@@ -243,9 +260,9 @@ match:
 #include "lzo1a_cr.ch"
 
 static int
-do_compress    ( const lzo_bytep in , lzo_uint  in_len,
+do_compress(const lzo_bytep in , lzo_uint  in_len,
             lzo_bytep out, lzo_uintp out_len,
-                       lzo_voidp wrkmem )
+            lzo_voidp wrkmem)
 {
     const lzo_bytep ip;
 #if defined(__LZO_HASH_INCREMENTAL)
@@ -253,8 +270,8 @@ do_compress    ( const lzo_bytep in , lzo_uint  in_len,
 #endif
     const lzo_bytep m_pos;
     lzo_bytep op;
-    const lzo_bytep const ip_end = in+in_len - DVAL_LEN - MIN_MATCH_LONG;
-    const lzo_bytep const in_end = in+in_len - DVAL_LEN;
+    const lzo_bytep const ip_end = in + in_len - DVAL_LEN - MIN_MATCH_LONG;
+    const lzo_bytep const in_end = in + in_len - DVAL_LEN;
     const lzo_bytep ii;
     lzo_dict_p const dict = (lzo_dict_p) wrkmem;
     const lzo_bytep r1 = ip_end;    /* pointer for R1 match (none yet) */
@@ -272,38 +289,49 @@ do_compress    ( const lzo_bytep in , lzo_uint  in_len,
 
     /* init dictionary */
 #if (LZO_DETERMINISTIC)
-    BZERO8_PTR(wrkmem,sizeof(lzo_dict_t),D_SIZE);
+    BZERO8_PTR(wrkmem, sizeof(lzo_dict_t), D_SIZE);
 #endif
 
-    DVAL_FIRST(dv,ip); UPDATE_D(dict,0,dv,ip,in); ip++;
-    DVAL_NEXT(dv,ip);
+    DVAL_FIRST(dv, ip);
+    UPDATE_D(dict, 0, dv, ip, in);
+    ip++;
+    DVAL_NEXT(dv, ip);
 
-    do {
+    do
+    {
         LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, m_off, 0);
         lzo_uint dindex;
 
-        DINDEX1(dindex,ip);
-        GINDEX(m_pos,m_off,dict,dindex,in);
-        if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,MAX_OFFSET))
+        DINDEX1(dindex, ip);
+        GINDEX(m_pos, m_off, dict, dindex, in);
+
+        if (LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, MAX_OFFSET))
             goto literal;
+
         if (m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2])
             goto match;
-        DINDEX2(dindex,ip);
-        GINDEX(m_pos,m_off,dict,dindex,in);
-        if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,MAX_OFFSET))
+
+        DINDEX2(dindex, ip);
+        GINDEX(m_pos, m_off, dict, dindex, in);
+
+        if (LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, MAX_OFFSET))
             goto literal;
+
         if (m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2])
             goto match;
+
         goto literal;
 
 literal:
-        UPDATE_I(dict,0,dindex,ip,in);
+        UPDATE_I(dict, 0, dindex, ip, in);
+
         if (++ip >= ip_end)
             break;
+
         continue;
 
 match:
-        UPDATE_I(dict,0,dindex,ip,in);
+        UPDATE_I(dict, 0, dindex, ip, in);
 #if !defined(NDEBUG) && (LZO_DICT_USE_PTR)
         assert(m_pos == NULL || m_pos >= in);
         m_pos_sav = m_pos;
@@ -320,9 +348,9 @@ match:
             assert(ip < ip_end);
 
             /* 1) store the current literal run */
-            if (pd(ip,ii) > 0)
+            if (pd(ip, ii) > 0)
             {
-                lzo_uint t = pd(ip,ii);
+                lzo_uint t = pd(ip, ii);
 
                 if (ip - r1 == MIN_MATCH + 1)
                 {
@@ -350,7 +378,7 @@ match:
                 {
                     /* inline the copying of a short run */
 #if (LBITS < 8)
-                    if (t < (1 << (8-LBITS)) && ii - im >= MIN_MATCH_LONG)
+                    if (t < (1 << (8 - LBITS)) && ii - im >= MIN_MATCH_LONG)
                     {
                         /* Code a very short literal run into the
                          * previous long match length byte.
@@ -376,13 +404,15 @@ match:
                 {
                     /* inline the copying of a short R0 run */
                     LZO_STATS(lzo_stats->r0short_runs++);
-                    *op++ = 0; *op++ = LZO_BYTE(t - R0MIN);
+                    *op++ = 0;
+                    *op++ = LZO_BYTE(t - R0MIN);
                     MEMCPY_DS(op, ii, t);
                     r1 = ip;                /* set new R1 pointer */
                 }
                 else
-                    op = store_run(op,ii,t);
+                    op = store_run(op, ii, t);
             }
+
 #if (LBITS < 8)
             im = ip;
 #endif
@@ -402,6 +432,7 @@ match:
 #define PS  *m_pos++ != *ip++
 
 #if (MIN_MATCH_LONG - MIN_MATCH == 2)                   /* MBITS == 2 */
+
             if (PS || PS)
 #elif (MIN_MATCH_LONG - MIN_MATCH == 6)                 /* MBITS == 3 */
             if (PS || PS || PS || PS || PS || PS)
@@ -421,15 +452,15 @@ match:
                 lzo_uint m_len;
 
                 /* 2a) compute match parameters */
-                    assert(ip-m_pos == (int)m_off);
+                assert(ip - m_pos == (int)m_off);
                 --ip;   /* ran one too far, point back to non-match */
                 m_len = pd(ip, ii);
                 assert(m_len >= MIN_MATCH_SHORT);
                 assert(m_len <= MAX_MATCH_SHORT);
                 assert(m_off >= MIN_OFFSET);
                 assert(m_off <= MAX_OFFSET);
-                    assert(ii-m_off == m_pos_sav);
-                    assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
+                assert(ii - m_off == m_pos_sav);
+                assert(lzo_memcmp(m_pos_sav, ii, m_len) == 0);
                 m_off -= MIN_OFFSET;
 
                 /* 2b) code a short match */
@@ -443,12 +474,16 @@ match:
 #if (LZO_COLLECT_STATS)
                 lzo_stats->short_matches++;
                 lzo_stats->short_match[m_len]++;
+
                 if (m_off < OSIZE)
                     lzo_stats->short_match_offset_osize[m_len]++;
+
                 if (m_off < 256)
                     lzo_stats->short_match_offset_256[m_len]++;
+
                 if (m_off < 1024)
                     lzo_stats->short_match_offset_1024[m_len]++;
+
 #endif
 
 
@@ -461,13 +496,17 @@ match:
 #if (CLEVEL == 9) || (CLEVEL >= 7 && MBITS <= 4) || (CLEVEL >= 5 && MBITS <= 3)
                 /* Insert the whole match (ii+1)..(ip-1) into dictionary.  */
                 ++ii;
-                do {
-                    DVAL_NEXT(dv,ii);
-                    UPDATE_D(dict,0,dv,ii,in);
-                } while (++ii < ip);
-                DVAL_NEXT(dv,ii);
+
+                do
+                {
+                    DVAL_NEXT(dv, ii);
+                    UPDATE_D(dict, 0, dv, ii, in);
+                }
+                while (++ii < ip);
+
+                DVAL_NEXT(dv, ii);
                 assert(ii == ip);
-                DVAL_ASSERT(dv,ip);
+                DVAL_ASSERT(dv, ip);
 #elif (CLEVEL >= 3)
                 SI   DI DI   XI
 #elif (CLEVEL >= 2)
@@ -486,7 +525,7 @@ match:
                 assert(ip <= in_end);
                 assert(ii == ip - MIN_MATCH_LONG);
 
-                if (pd(in_end,ip) <= (MAX_MATCH_LONG - MIN_MATCH_LONG))
+                if (pd(in_end, ip) <= (MAX_MATCH_LONG - MIN_MATCH_LONG))
                     end = in_end;
                 else
                 {
@@ -496,6 +535,7 @@ match:
 
                 while (ip < end  &&  *m_pos == *ip)
                     m_pos++, ip++;
+
                 assert(ip <= in_end);
 
                 /* 2a) compute match parameters */
@@ -504,9 +544,9 @@ match:
                 assert(m_len <= MAX_MATCH_LONG);
                 assert(m_off >= MIN_OFFSET);
                 assert(m_off <= MAX_OFFSET);
-                    assert(ii-m_off == m_pos_sav);
-                    assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
-                    assert(pd(ip,m_pos) == m_off);
+                assert(ii - m_off == m_pos_sav);
+                assert(lzo_memcmp(m_pos_sav, ii, m_len) == 0);
+                assert(pd(ip, m_pos) == m_off);
                 m_off -= MIN_OFFSET;
 
                 /* 2b) code the long match */
@@ -529,13 +569,17 @@ match:
                 /* Insert the whole match (ii+1)..(ip-1) into dictionary.  */
                 /* This is not recommended because it is slow. */
                 ++ii;
-                do {
-                    DVAL_NEXT(dv,ii);
-                    UPDATE_D(dict,0,dv,ii,in);
-                } while (++ii < ip);
-                DVAL_NEXT(dv,ii);
+
+                do
+                {
+                    DVAL_NEXT(dv, ii);
+                    UPDATE_D(dict, 0, dv, ii, in);
+                }
+                while (++ii < ip);
+
+                DVAL_NEXT(dv, ii);
                 assert(ii == ip);
-                DVAL_ASSERT(dv,ip);
+                DVAL_ASSERT(dv, ip);
 #elif (CLEVEL >= 8)
                 SI   DI DI DI DI DI DI DI DI   XI
 #elif (CLEVEL >= 7)
@@ -559,12 +603,14 @@ match:
             assert(ii == ip);
         }
 
-    } while (ip < ip_end);
+    }
+    while (ip < ip_end);
 
     assert(ip <= in_end);
 
 
 #if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
+
     /* return -1 if op == out to indicate that we
      * couldn't compress and didn't copy anything.
      */
@@ -573,11 +619,12 @@ match:
         *out_len = 0;
         return LZO_E_NOT_COMPRESSIBLE;
     }
+
 #endif
 
     /* store the final literal run */
-    if (pd(in_end+DVAL_LEN,ii) > 0)
-        op = store_run(op,ii,pd(in_end+DVAL_LEN,ii));
+    if (pd(in_end + DVAL_LEN, ii) > 0)
+        op = store_run(op, ii, pd(in_end + DVAL_LEN, ii));
 
     *out_len = pd(op, out);
     return 0;               /* compression went ok */
@@ -589,15 +636,15 @@ match:
 ************************************************************************/
 
 LZO_PUBLIC(int)
-lzo1a_compress ( const lzo_bytep in , lzo_uint  in_len,
+lzo1a_compress(const lzo_bytep in , lzo_uint  in_len,
                lzo_bytep out, lzo_uintp out_len,
-                       lzo_voidp wrkmem )
+               lzo_voidp wrkmem)
 {
     int r = LZO_E_OK;
 
 
 #if (LZO_COLLECT_STATS)
-    lzo_memset(lzo_stats,0,sizeof(*lzo_stats));
+    lzo_memset(lzo_stats, 0, sizeof(*lzo_stats));
     lzo_stats->rbits  = RBITS;
     lzo_stats->clevel = CLEVEL;
     lzo_stats->dbits  = DBITS;
@@ -623,11 +670,11 @@ lzo1a_compress ( const lzo_bytep in , lzo_uint  in_len,
 #if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
         r = LZO_E_NOT_COMPRESSIBLE;
 #else
-        *out_len = pd(store_run(out,in,in_len), out);
+        *out_len = pd(store_run(out, in, in_len), out);
 #endif
     }
     else
-        r = do_compress(in,in_len,out,out_len,wrkmem);
+        r = do_compress(in, in_len, out, out_len, wrkmem);
 
 
 #if (LZO_COLLECT_STATS)

extern/lzo/src/lzo1a_99.c

@@ -46,10 +46,10 @@
 ************************************************************************/
 
 static int
-_lzo1a_do_compress ( const lzo_bytep in,  lzo_uint  in_len,
+_lzo1a_do_compress(const lzo_bytep in,  lzo_uint  in_len,
                    lzo_bytep out, lzo_uintp out_len,
                    lzo_voidp wrkmem,
-                           lzo_compress_t func )
+                   lzo_compress_t func)
 {
     int r;
 
@@ -65,12 +65,12 @@ _lzo1a_do_compress ( const lzo_bytep in,  lzo_uint  in_len,
         *out_len = 0;
         r = LZO_E_NOT_COMPRESSIBLE;
 #else
-        *out_len = pd(STORE_RUN(out,in,in_len), out);
+        *out_len = pd(STORE_RUN(out, in, in_len), out);
         r = (*out_len > in_len) ? LZO_E_OK : LZO_E_ERROR;
 #endif
     }
     else
-        r = func(in,in_len,out,out_len,wrkmem);
+        r = func(in, in_len, out, out_len, wrkmem);
 
     return r;
 }
@@ -105,11 +105,11 @@ _lzo1a_do_compress ( const lzo_bytep in,  lzo_uint  in_len,
 ************************************************************************/
 
 LZO_PUBLIC(int)
-LZO_COMPRESS ( const lzo_bytep in,  lzo_uint  in_len,
+LZO_COMPRESS(const lzo_bytep in,  lzo_uint  in_len,
              lzo_bytep out, lzo_uintp out_len,
-                     lzo_voidp wrkmem )
+             lzo_voidp wrkmem)
 {
-    return _lzo1a_do_compress(in,in_len,out,out_len,wrkmem,do_compress);
+    return _lzo1a_do_compress(in, in_len, out, out_len, wrkmem, do_compress);
 }
 
 

extern/lzo/src/lzo1a_cm.ch

@@ -47,35 +47,35 @@
 
 #if (DD_BITS == 0)
 
-        /* we already matched M2_MIN_LEN bytes,
+/* we already matched M2_MIN_LEN bytes,
  * m_pos also already advanced M2_MIN_LEN bytes */
-        ip += M2_MIN_LEN;
-        assert(m_pos < ip);
+ip += M2_MIN_LEN;
+assert(m_pos < ip);
 
-        /* try to match another M2_MAX_LEN + 1 - M2_MIN_LEN bytes
+/* try to match another M2_MAX_LEN + 1 - M2_MIN_LEN bytes
  * to see if we get more than a M2 match */
 #define M2_OR_M3    (MATCH_M2)
 
 #else /* (DD_BITS == 0) */
 
-        /* we already matched m_len bytes */
-        assert(m_len >= M2_MIN_LEN);
-        ip += m_len;
-        assert(ip <= in_end);
+/* we already matched m_len bytes */
+assert(m_len >= M2_MIN_LEN);
+ip += m_len;
+assert(ip <= in_end);
 
 #define M2_OR_M3    (m_len <= M2_MAX_LEN)
 
 #endif /* (DD_BITS == 0) */
 
 
-        if (M2_OR_M3)
-        {
+if (M2_OR_M3)
+{
     /* we've found a short match */
     assert(ip <= in_end);
 
     /* 2a) compute match parameters */
 #if (DD_BITS == 0)
-                assert(pd(ip,m_pos) == m_off);
+    assert(pd(ip, m_pos) == m_off);
     --ip;   /* ran one too far, point back to non-match */
     m_len = ip - ii;
 #endif
@@ -84,8 +84,8 @@
 
     assert(m_off >= M2_MIN_OFFSET);
     assert(m_off <= M2_MAX_OFFSET);
-                assert(ii-m_off == m_pos_sav);
-                assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
+    assert(ii - m_off == m_pos_sav);
+    assert(lzo_memcmp(m_pos_sav, ii, m_len) == 0);
 
     /* 2b) code the match */
     m_off -= M2_MIN_OFFSET;
@@ -108,18 +108,22 @@
 #if (CLEVEL == 9) || (CLEVEL >= 7 && M2L_BITS <= 4) || (CLEVEL >= 5 && M2L_BITS <= 3)
     /* Insert the whole match (ii+1)..(ip-1) into dictionary.  */
     ++ii;
-            do {
-                DVAL_NEXT(dv,ii);
+
+    do
+    {
+        DVAL_NEXT(dv, ii);
 #if 0
-                UPDATE_D(dict,drun,dv,ii,in);
+        UPDATE_D(dict, drun, dv, ii, in);
 #else
-                dict[ DINDEX(dv,ii) ] = DENTRY(ii,in);
+        dict[ DINDEX(dv, ii) ] = DENTRY(ii, in);
 #endif
         MI
-            } while (++ii < ip);
-            DVAL_NEXT(dv,ii);
+    }
+    while (++ii < ip);
+
+    DVAL_NEXT(dv, ii);
     assert(ii == ip);
-            DVAL_ASSERT(dv,ip);
+    DVAL_ASSERT(dv, ip);
 #elif (CLEVEL >= 3)
     SI   DI DI   XI
 #elif (CLEVEL >= 2)
@@ -127,25 +131,25 @@
 #else
     XI
 #endif
-        }
+}
 
-        else
+else
 
-        {
+{
     /* we've found a long match - see how far we can still go */
     const lzo_bytep end;
 
     assert(ip <= in_end);
     assert(ii == ip - (M2_MAX_LEN + 1));
-            assert(lzo_memcmp(m_pos_sav,ii,(lzo_uint)(ip-ii)) == 0);
+    assert(lzo_memcmp(m_pos_sav, ii, (lzo_uint)(ip - ii)) == 0);
 
 #if (DD_BITS > 0)
-            assert(m_len == (lzo_uint)(ip-ii));
+    assert(m_len == (lzo_uint)(ip - ii));
     m_pos = ip - m_off;
     assert(m_pos == m_pos_sav + m_len);
 #endif
 
-            if (pd(in_end,ip) <= (M3_MAX_LEN - M3_MIN_LEN))
+    if (pd(in_end, ip) <= (M3_MAX_LEN - M3_MIN_LEN))
         end = in_end;
     else
     {
@@ -155,6 +159,7 @@
 
     while (ip < end  &&  *m_pos == *ip)
         m_pos++, ip++;
+
     assert(ip <= in_end);
 
     /* 2a) compute match parameters */
@@ -164,9 +169,9 @@
 
     assert(m_off >= M3_MIN_OFFSET);
     assert(m_off <= M3_MAX_OFFSET);
-                assert(ii-m_off == m_pos_sav);
-                assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
-                assert(pd(ip,m_pos) == m_off);
+    assert(ii - m_off == m_pos_sav);
+    assert(lzo_memcmp(m_pos_sav, ii, m_len) == 0);
+    assert(pd(ip, m_pos) == m_off);
 
     /* 2b) code the match */
     m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET;
@@ -190,18 +195,22 @@
     /* Insert the whole match (ii+1)..(ip-1) into dictionary.  */
     /* This is not recommended because it can be slow. */
     ++ii;
-            do {
-                DVAL_NEXT(dv,ii);
+
+    do
+    {
+        DVAL_NEXT(dv, ii);
 #if 0
-                UPDATE_D(dict,drun,dv,ii,in);
+        UPDATE_D(dict, drun, dv, ii, in);
 #else
-                dict[ DINDEX(dv,ii) ] = DENTRY(ii,in);
+        dict[ DINDEX(dv, ii) ] = DENTRY(ii, in);
 #endif
         MI
-            } while (++ii < ip);
-            DVAL_NEXT(dv,ii);
+    }
+    while (++ii < ip);
+
+    DVAL_NEXT(dv, ii);
     assert(ii == ip);
-            DVAL_ASSERT(dv,ip);
+    DVAL_ASSERT(dv, ip);
 #elif (CLEVEL >= 8)
     SI   DI DI DI DI DI DI DI DI   XI
 #elif (CLEVEL >= 7)
@@ -219,10 +228,10 @@
 #else
     XI
 #endif
-        }
+}
 
-        /* ii now points to the start of the next literal run */
-        assert(ii == ip);
+/* ii now points to the start of the next literal run */
+assert(ii == ip);
 
 
 /* vim:set ts=4 sw=4 et: */

extern/lzo/src/lzo1a_cr.ch

@@ -60,37 +60,48 @@ store_run(lzo_bytep const oo, const lzo_bytep const ii, lzo_uint r_len)
         while (r_len >= (t = tt))
         {
             r_len -= t;
-            *op++ = 0; *op++ = (R0MAX - R0MIN);
+            *op++ = 0;
+            *op++ = (R0MAX - R0MIN);
             MEMCPY8_DS(op, ip, t);
             LZO_STATS(lzo_stats->r0long_runs++);
         }
+
         tt >>= 1;
-        do {
+
+        do
+        {
             if (r_len >= (t = tt))
             {
                 r_len -= t;
-                *op++ = 0; *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits);
+                *op++ = 0;
+                *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits);
                 MEMCPY8_DS(op, ip, t);
                 LZO_STATS(lzo_stats->r0long_runs++);
             }
+
             tt >>= 1;
-        } while (--r_bits > 0);
         }
+        while (--r_bits > 0);
+    }
+
     assert(r_len < 512);
 
     while (r_len >= (t = R0FAST))
     {
         r_len -= t;
-        *op++ = 0; *op++ = (R0FAST - R0MIN);
+        *op++ = 0;
+        *op++ = (R0FAST - R0MIN);
         MEMCPY8_DS(op, ip, t);
         LZO_STATS(lzo_stats->r0fast_runs++);
     }
 
     t = r_len;
+
     if (t >= R0MIN)
     {
         /* code a short R0 run */
-        *op++ = 0; *op++ = LZO_BYTE(t - R0MIN);
+        *op++ = 0;
+        *op++ = LZO_BYTE(t - R0MIN);
         MEMCPY_DS(op, ip, t);
         LZO_STATS(lzo_stats->r0short_runs++);
     }

extern/lzo/src/lzo1b_9x.c

@@ -50,7 +50,7 @@
 ************************************************************************/
 
 static lzo_bytep
-code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
+code_match(LZO_COMPRESS_T* c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off)
 {
     if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
     {
@@ -71,6 +71,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
         assert(m_off <= M3_MAX_OFFSET);
 
         m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET;
+
         /* code match len */
         if (m_len <= M3_MAX_LEN)
             *op++ = LZO_BYTE(M3_MARKER | (m_len - (M3_MIN_LEN - 1)));
@@ -81,14 +82,17 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
             *op++ = M4_MARKER;
             /* code match len */
             m_len -= M4_MIN_LEN - 1;
+
             while (m_len > 255)
             {
                 m_len -= 255;
                 *op++ = 0;
             }
+
             assert(m_len > 0);
             *op++ = LZO_BYTE(m_len);
         }
+
         /* code low offset bits */
         *op++ = LZO_BYTE(m_off & M3O_MASK);
         /* code high offset bits */
@@ -97,6 +101,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
         c->r1_m_len = 0;
         c->m3_m++;
     }
+
     return op;
 }
 
@@ -106,25 +111,25 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
 ************************************************************************/
 
 LZO_EXTERN(int)
-lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
+lzo1b_999_compress_callback(const lzo_bytep in , lzo_uint  in_len,
                             lzo_bytep out, lzo_uintp out_len,
                             lzo_voidp wrkmem,
                             lzo_callback_p cb,
-                                    lzo_uint max_chain );
+                            lzo_uint max_chain);
 
 LZO_PUBLIC(int)
-lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
+lzo1b_999_compress_callback(const lzo_bytep in , lzo_uint  in_len,
                             lzo_bytep out, lzo_uintp out_len,
                             lzo_voidp wrkmem,
                             lzo_callback_p cb,
-                                    lzo_uint max_chain )
+                            lzo_uint max_chain)
 {
     lzo_bytep op;
     const lzo_bytep ii;
     lzo_uint lit;
     lzo_uint m_len, m_off;
     LZO_COMPRESS_T cc;
-    LZO_COMPRESS_T * const c = &cc;
+    LZO_COMPRESS_T* const c = &cc;
     lzo_swd_p const swd = (lzo_swd_p) wrkmem;
     int r;
 
@@ -142,15 +147,19 @@ lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
     lit = 0;
     c->r1_m_len = 0;
 
-    r = init_match(c,swd,NULL,0,0);
+    r = init_match(c, swd, NULL, 0, 0);
+
     if (r != 0)
         return r;
+
     if (max_chain > 0)
         swd->max_chain = max_chain;
 
-    r = find_match(c,swd,0,0);
+    r = find_match(c, swd, 0, 0);
+
     if (r != 0)
         return r;
+
     while (c->look > 0)
     {
         int lazy_match_min_gain = -1;
@@ -160,13 +169,15 @@ lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
         m_off = c->m_off;
 
 #if 0
-        printf("%5ld: %5d len:%3d off:%5d\n", (c->ip-c->look)-in, c->look,
+        printf("%5ld: %5d len:%3d off:%5d\n", (c->ip - c->look) - in, c->look,
                m_len, m_off);
 #endif
 
         assert(c->ip - c->look >= in);
+
         if (lit == 0)
             ii = c->ip - c->look;
+
         assert(ii + lit == c->ip - c->look);
         assert(swd->b_char == *(c->ip - c->look));
 
@@ -192,20 +203,24 @@ lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
                     lazy_match_min_gain = 1;
 
 #if (M2_MIN_LEN == 2)
+
                 if (m_len == 2)
                 {
                     /* don't code a match of len 2 if we have to
                        code a literal run. Code a literal instead. */
                     m_len = 0;
                 }
+
 #endif
 #if (M2_MIN_LEN == M3_MIN_LEN)
+
                 if (m_len == M2_MIN_LEN && m_off > M2_MAX_OFFSET)
                 {
                     /* don't code a M3 match of len 3 if we have to
                        code a literal run. Code a literal instead. */
                     m_len = 0;
                 }
+
 #endif
             }
             else
@@ -223,12 +238,14 @@ lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
         /* try a lazy match */
         if (m_len == 0)
             lazy_match_min_gain = -1;
+
         if (lazy_match_min_gain >= 0 && c->look > m_len)
         {
             assert(m_len > 0);
 
-            r = find_match(c,swd,1,0);
-            assert(r == 0); LZO_UNUSED(r);
+            r = find_match(c, swd, 1, 0);
+            assert(r == 0);
+            LZO_UNUSED(r);
             assert(c->look > 0);
 
             if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET &&
@@ -253,8 +270,10 @@ lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
                 ahead = 1;
                 assert(ii + lit + 1 == c->ip - c->look);
             }
+
             assert(m_len > 0);
         }
+
         assert(ii + lit + ahead == c->ip - c->look);
 
 
@@ -262,8 +281,9 @@ lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
         {
             /* a literal */
             lit++;
-            r = find_match(c,swd,1,0);
-            assert(r == 0); LZO_UNUSED(r);
+            r = find_match(c, swd, 1, 0);
+            assert(r == 0);
+            LZO_UNUSED(r);
         }
         else
         {
@@ -284,21 +304,24 @@ lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
                 }
                 else
                 {
-                    op = STORE_RUN(op,ii,lit);
+                    op = STORE_RUN(op, ii, lit);
                 }
+
                 if (lit < R0FAST)
                     c->r1_m_len = m_len;
                 else
                     c->r1_m_len = 0;
+
                 lit = 0;
             }
             else
                 c->r1_m_len = 0;
 
             /* 2 - code match */
-            op = code_match(c,op,m_len,m_off);
-            r = find_match(c,swd,m_len,1+ahead);
-            assert(r == 0); LZO_UNUSED(r);
+            op = code_match(c, op, m_len, m_off);
+            r = find_match(c, swd, m_len, 1 + ahead);
+            assert(r == 0);
+            LZO_UNUSED(r);
         }
 
         c->codesize = pd(op, out);
@@ -307,7 +330,7 @@ lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
 
     /* store final run */
     if (lit > 0)
-        op = STORE_RUN(op,ii,lit);
+        op = STORE_RUN(op, ii, lit);
 
 #if defined(LZO_EOF_CODE)
     *op++ = M3_MARKER | 1;
@@ -338,11 +361,11 @@ lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
 ************************************************************************/
 
 LZO_PUBLIC(int)
-lzo1b_999_compress  ( const lzo_bytep in , lzo_uint  in_len,
+lzo1b_999_compress(const lzo_bytep in , lzo_uint  in_len,
                    lzo_bytep out, lzo_uintp out_len,
-                            lzo_voidp wrkmem )
+                   lzo_voidp wrkmem)
 {
-    return lzo1b_999_compress_callback(in,in_len,out,out_len,wrkmem,
+    return lzo1b_999_compress_callback(in, in_len, out, out_len, wrkmem,
                                        (lzo_callback_p) 0, 0);
 }
 

extern/lzo/src/lzo1b_c.ch

@@ -63,9 +63,9 @@
 extern "C" {
 #endif
 LZO_PRIVATE(int)
-do_compress    ( const lzo_bytep in , lzo_uint  in_len,
+do_compress(const lzo_bytep in , lzo_uint  in_len,
             lzo_bytep out, lzo_uintp out_len,
-                       lzo_voidp wrkmem )
+            lzo_voidp wrkmem)
 {
     const lzo_bytep ip;
 #if (DD_BITS > 0)
@@ -101,7 +101,7 @@ do_compress    ( const lzo_bytep in , lzo_uint  in_len,
 
     /* init dictionary */
 #if (LZO_DETERMINISTIC)
-    BZERO8_PTR(wrkmem,sizeof(lzo_dict_t),D_SIZE);
+    BZERO8_PTR(wrkmem, sizeof(lzo_dict_t), D_SIZE);
 #endif
 
 
@@ -111,15 +111,16 @@ do_compress    ( const lzo_bytep in , lzo_uint  in_len,
 
 
 #if (DD_BITS > 0)
-    DVAL_FIRST(dv,ip);
-    UPDATE_D(dict,drun,dv,ip,in);
+    DVAL_FIRST(dv, ip);
+    UPDATE_D(dict, drun, dv, ip, in);
     ip++;
-    DVAL_NEXT(dv,ip);
+    DVAL_NEXT(dv, ip);
 #else
     ip++;
 #endif
 
     assert(ip < ip_end);
+
     for (;;)
     {
         const lzo_bytep m_pos;
@@ -133,9 +134,9 @@ do_compress    ( const lzo_bytep in , lzo_uint  in_len,
         lzo_uint m_len;
 
 
-/***********************************************************************
-// search for a match
-************************************************************************/
+        /***********************************************************************
+        // search for a match
+        ************************************************************************/
 
 #if !defined(LZO_SEARCH_MATCH_INCLUDE_FILE)
 #  define LZO_SEARCH_MATCH_INCLUDE_FILE     "lzo1b_sm.ch"
@@ -152,32 +153,34 @@ do_compress    ( const lzo_bytep in , lzo_uint  in_len,
 
 
 
-/***********************************************************************
-// found a literal
-************************************************************************/
+        /***********************************************************************
+        // found a literal
+        ************************************************************************/
 
 
         /* a literal */
 literal:
 #if (DD_BITS == 0)
-        UPDATE_I(dict,0,dindex,ip,in);
+        UPDATE_I(dict, 0, dindex, ip, in);
 #endif
+
         if (++ip >= ip_end)
             break;
+
 #if (DD_BITS > 0)
-        DVAL_NEXT(dv,ip);
+        DVAL_NEXT(dv, ip);
 #endif
         continue;
 
 
 
-/***********************************************************************
-// found a match
-************************************************************************/
+        /***********************************************************************
+        // found a match
+        ************************************************************************/
 
 match:
 #if (DD_BITS == 0)
-        UPDATE_I(dict,0,dindex,ip,in);
+        UPDATE_I(dict, 0, dindex, ip, in);
 #endif
         /* we have found a match of at least M2_MIN_LEN */
 
@@ -193,9 +196,9 @@ match:
         assert(ii == ip);
 
 
-/***********************************************************************
-// code the match
-************************************************************************/
+        /***********************************************************************
+        // code the match
+        ************************************************************************/
 
 #if !defined(LZO_CODE_MATCH_INCLUDE_FILE)
 #  define LZO_CODE_MATCH_INCLUDE_FILE   "lzo1b_cm.ch"
@@ -210,9 +213,9 @@ match:
     }
 
 
-/***********************************************************************
-// end of block
-************************************************************************/
+    /***********************************************************************
+    // end of block
+    ************************************************************************/
 
     assert(ip <= in_end);
 
@@ -224,9 +227,11 @@ match:
         for (i = 0; i < D_SIZE; i++)
         {
             p = dict[i];
+
             if (BOUNDS_CHECKING_OFF_IN_EXPR(p == NULL || p < in || p > in_end))
                 lzo_stats->unused_dict_entries++;
         }
+
         lzo_stats->unused_dict_entries_percent =
             100.0 * lzo_stats->unused_dict_entries / D_SIZE;
     }
@@ -234,6 +239,7 @@ match:
 
 
 #if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
+
     /* return if op == out to indicate that we
      * couldn't compress and didn't copy anything.
      */
@@ -242,13 +248,14 @@ match:
         *out_len = 0;
         return LZO_E_NOT_COMPRESSIBLE;
     }
+
 #endif
 
     /* store the final literal run */
-    if (pd(in_end,ii) > 0)
+    if (pd(in_end, ii) > 0)
     {
-        lzo_uint t = pd(in_end,ii);
-        op = STORE_RUN(op,ii,t);
+        lzo_uint t = pd(in_end, ii);
+        op = STORE_RUN(op, ii, t);
     }
 
     *out_len = pd(op, out);

extern/lzo/src/lzo1b_cc.c

@@ -35,10 +35,10 @@
 ************************************************************************/
 
 LZO_LOCAL_IMPL(int)
-_lzo1b_do_compress   ( const lzo_bytep in,  lzo_uint  in_len,
+_lzo1b_do_compress(const lzo_bytep in,  lzo_uint  in_len,
                    lzo_bytep out, lzo_uintp out_len,
                    lzo_voidp wrkmem,
-                             lzo_compress_t func )
+                   lzo_compress_t func)
 {
     int r;
 #if defined(LZO_TEST_COMPRESS_OVERRUN)
@@ -64,19 +64,22 @@ _lzo1b_do_compress   ( const lzo_bytep in,  lzo_uint  in_len,
         *out_len = 0;
         r = LZO_E_NOT_COMPRESSIBLE;
 #else
-        *out_len = pd(STORE_RUN(out,in,in_len), out);
+        *out_len = pd(STORE_RUN(out, in, in_len), out);
         r = (*out_len > in_len) ? LZO_E_OK : LZO_E_ERROR;
 #endif
     }
     else
-        r = func(in,in_len,out,out_len,wrkmem);
+        r = func(in, in_len, out, out_len, wrkmem);
 
 
 #if defined(LZO_EOF_CODE)
 #if defined(LZO_TEST_COMPRESS_OVERRUN)
+
     if (r == LZO_E_OK && avail_out - *out_len < 3)
         r = LZO_E_COMPRESS_OVERRUN;
+
 #endif
+
     if (r == LZO_E_OK)
     {
         lzo_bytep op = out + *out_len;
@@ -85,6 +88,7 @@ _lzo1b_do_compress   ( const lzo_bytep in,  lzo_uint  in_len,
         op[2] = 0;
         *out_len += 3;
     }
+
 #endif
 
 
@@ -112,16 +116,16 @@ _lzo1b_do_compress   ( const lzo_bytep in,  lzo_uint  in_len,
 #if (LZO_COLLECT_STATS)
 
 static lzo_stats_t lzo_statistics;
-lzo_stats_t * const lzo1b_stats = &lzo_statistics;
+lzo_stats_t* const lzo1b_stats = &lzo_statistics;
 
 
-void _lzo1b_stats_init(lzo_stats_t *lzo_stats)
+void _lzo1b_stats_init(lzo_stats_t* lzo_stats)
 {
-    lzo_memset(lzo_stats,0,sizeof(*lzo_stats));
+    lzo_memset(lzo_stats, 0, sizeof(*lzo_stats));
 }
 
 
-void _lzo1b_stats_calc(lzo_stats_t *lzo_stats)
+void _lzo1b_stats_calc(lzo_stats_t* lzo_stats)
 {
     lzo_stats->matches =
         lzo_stats->m1_matches + lzo_stats->m2_matches +

extern/lzo/src/lzo1b_cc.h

@@ -57,18 +57,18 @@ extern const lzo_compress_t _lzo1b_99_compress_func;
 //
 ************************************************************************/
 
-LZO_LOCAL_DECL(lzo_bytep )
-_lzo1b_store_run ( lzo_bytep const oo, const lzo_bytep const ii,
+LZO_LOCAL_DECL(lzo_bytep)
+_lzo1b_store_run(lzo_bytep const oo, const lzo_bytep const ii,
                  lzo_uint r_len);
 
 #define STORE_RUN   _lzo1b_store_run
 
 
 LZO_LOCAL_DECL(int)
-_lzo1b_do_compress ( const lzo_bytep in,  lzo_uint  in_len,
+_lzo1b_do_compress(const lzo_bytep in,  lzo_uint  in_len,
                    lzo_bytep out, lzo_uintp out_len,
                    lzo_voidp wrkmem,
-                           lzo_compress_t func );
+                   lzo_compress_t func);
 
 
 #endif /* already included */

extern/lzo/src/lzo1b_cm.ch

@@ -39,21 +39,21 @@
 
 #if (DD_BITS == 0)
 
-        /* we already matched M2_MIN_LEN bytes,
+/* we already matched M2_MIN_LEN bytes,
  * m_pos also already advanced M2_MIN_LEN bytes */
-        ip += M2_MIN_LEN;
-        assert(m_pos < ip);
+ip += M2_MIN_LEN;
+assert(m_pos < ip);
 
-        /* try to match another M2_MAX_LEN + 1 - M2_MIN_LEN bytes
+/* try to match another M2_MAX_LEN + 1 - M2_MIN_LEN bytes
  * to see if we get more than a M2 match */
 #define M2_OR_M3    (MATCH_M2)
 
 #else /* (DD_BITS == 0) */
 
-        /* we already matched m_len bytes */
-        assert(m_len >= M2_MIN_LEN);
-        ip += m_len;
-        assert(ip <= in_end);
+/* we already matched m_len bytes */
+assert(m_len >= M2_MIN_LEN);
+ip += m_len;
+assert(ip <= in_end);
 
 #define M2_OR_M3    (m_len <= M2_MAX_LEN)
 
@@ -61,14 +61,14 @@
 
 
 
-        if (M2_OR_M3)
-        {
+if (M2_OR_M3)
+{
     /* we've found a M2 or M3 match */
     assert(ip <= in_end);
 
     /* 2a) compute match parameters */
 #if (DD_BITS == 0)
-            assert(pd(ip,m_pos) == m_off);
+    assert(pd(ip, m_pos) == m_off);
     --ip;   /* ran one too far, point back to non-match */
     m_len = pd(ip, ii);
 #endif
@@ -81,11 +81,12 @@
     assert(m_off >= M2_MIN_OFFSET);
     assert(m_off >= M3_MIN_OFFSET);
     assert(m_off <= M3_MAX_OFFSET);
-            assert(ii-m_off == m_pos_sav);
-            assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
+    assert(ii - m_off == m_pos_sav);
+    assert(lzo_memcmp(m_pos_sav, ii, m_len) == 0);
 
     /* 2b) code the match */
 #if (_M2_MAX_OFFSET != _M3_MAX_OFFSET)
+
     if (m_off <= M2_MAX_OFFSET)
     {
 #else
@@ -122,6 +123,7 @@
         m3 = op;        /* set M3 pointer */
 #endif
     }
+
 #endif /* (_M2_MAX_OFFSET != _M3_MAX_OFFSET) */
 
 
@@ -137,18 +139,22 @@
 #if (CLEVEL == 9) || (CLEVEL >= 7 && M2L_BITS <= 4) || (CLEVEL >= 5 && M2L_BITS <= 3)
     /* Insert the whole match (ii+1)..(ip-1) into dictionary.  */
     ++ii;
-            do {
-                DVAL_NEXT(dv,ii);
+
+    do
+    {
+        DVAL_NEXT(dv, ii);
 #if 0
-                UPDATE_D(dict,drun,dv,ii,in);
+        UPDATE_D(dict, drun, dv, ii, in);
 #else
-                dict[ DINDEX(dv,ii) ] = DENTRY(ii,in);
+        dict[ DINDEX(dv, ii) ] = DENTRY(ii, in);
 #endif
         MI
-            } while (++ii < ip);
-            DVAL_NEXT(dv,ii);
+    }
+    while (++ii < ip);
+
+    DVAL_NEXT(dv, ii);
     assert(ii == ip);
-            DVAL_ASSERT(dv,ip);
+    DVAL_ASSERT(dv, ip);
 #elif (CLEVEL >= 3)
     SI   DI DI   XI
 #elif (CLEVEL >= 2)
@@ -156,32 +162,34 @@
 #else
     XI
 #endif
-        }
+}
 
-        else
+else
 
-        {
+{
     /* we've found a M3 or M4 match - see how far we can still go */
     assert(ip <= in_end);
-            assert(lzo_memcmp(m_pos_sav,ii,(lzo_uint)(ip-ii)) == 0);
+    assert(lzo_memcmp(m_pos_sav, ii, (lzo_uint)(ip - ii)) == 0);
 
     /* 2a) compute match parameters */
 #if !defined(MATCH_IP_END)
     assert(ii == ip - (M2_MAX_LEN + 1));
 #if (DD_BITS > 0)
-            assert(m_len == (lzo_uint)(ip-ii));
+    assert(m_len == (lzo_uint)(ip - ii));
     m_pos = ip - m_off;
     assert(m_pos == m_pos_sav + m_len);
 #endif
     {
         const lzo_bytep end;
         end = in_end;
+
         while (ip < end  &&  *m_pos == *ip)
             m_pos++, ip++;
+
         assert(ip <= in_end);
         m_len = pd(ip, ii);
     }
-            assert(pd(ip,m_pos) == m_off);
+    assert(pd(ip, m_pos) == m_off);
 #endif
 
     /* 2a2) verify match parameters */
@@ -191,8 +199,8 @@
     assert(m_off >= M4_MIN_OFFSET);
     assert(m_off <= M3_MAX_OFFSET);
     assert(m_off <= M4_MAX_OFFSET);
-            assert(ii-m_off == m_pos_sav);
-            assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
+    assert(ii - m_off == m_pos_sav);
+    assert(lzo_memcmp(m_pos_sav, ii, m_len) == 0);
 
     /* 2b) code the match */
     if (m_len <= M3_MAX_LEN)
@@ -209,11 +217,13 @@
         *op++ = M4_MARKER;
         /* code match len */
         m_len -= M4_MIN_LEN - 1;
+
         while (m_len > 255)
         {
             m_len -= 255;
             *op++ = 0;
         }
+
         assert(m_len > 0);
         *op++ = LZO_BYTE(m_len);
         LZO_STATS(lzo_stats->m4_matches++);
@@ -242,18 +252,22 @@
     /* Insert the whole match (ii+1)..(ip-1) into dictionary.  */
     /* This is not recommended because it can be slow. */
     ++ii;
-            do {
-                DVAL_NEXT(dv,ii);
+
+    do
+    {
+        DVAL_NEXT(dv, ii);
 #if 0
-                UPDATE_D(dict,drun,dv,ii,in);
+        UPDATE_D(dict, drun, dv, ii, in);
 #else
-                dict[ DINDEX(dv,ii) ] = DENTRY(ii,in);
+        dict[ DINDEX(dv, ii) ] = DENTRY(ii, in);
 #endif
         MI
-            } while (++ii < ip);
-            DVAL_NEXT(dv,ii);
+    }
+    while (++ii < ip);
+
+    DVAL_NEXT(dv, ii);
     assert(ii == ip);
-            DVAL_ASSERT(dv,ip);
+    DVAL_ASSERT(dv, ip);
 #elif (CLEVEL >= 8)
     SI   DI DI DI DI DI DI DI DI   XI
 #elif (CLEVEL >= 7)
@@ -271,10 +285,10 @@
 #else
     XI
 #endif
-        }
+}
 
-        /* ii now points to the start of the next literal run */
-        assert(ii == ip);
+/* ii now points to the start of the next literal run */
+assert(ii == ip);
 
 
 /* vim:set ts=4 sw=4 et: */

extern/lzo/src/lzo1b_cr.ch

@@ -37,12 +37,14 @@
 // store the current literal run
 ************************************************************************/
 
-        assert(ip < ip_end);
-        if (pd(ip,ii) > 0)
-        {
-            lzo_uint t = pd(ip,ii);
+assert(ip < ip_end);
+
+if (pd(ip, ii) > 0)
+{
+    lzo_uint t = pd(ip, ii);
 
 #if defined(LZO_HAVE_R1)
+
     if (ip == r1)
     {
         /* Code a context sensitive R1 match. */
@@ -66,7 +68,8 @@
             LZO_STATS(lzo_stats->lit_runs++);
             LZO_STATS(lzo_stats->lit_run[t]++);
 #if defined(LZO_HAVE_M3)
-                if (t < LZO_SIZE(8-M3O_BITS) && op == m3)
+
+            if (t < LZO_SIZE(8 - M3O_BITS) && op == m3)
             {
                 /* Code a very short literal run into the low offset bits
                  * of the previous M3/M4 match.
@@ -81,6 +84,7 @@
             {
                 *op++ = LZO_BYTE(t);
             }
+
             MEMCPY_DS(op, ii, t);
 #if defined(LZO_HAVE_R1)
             r1 = ip + (M2_MIN_LEN + 1);     /* set new R1 pointer */
@@ -91,7 +95,8 @@
             /* inline the copying of a short R0 run */
             LZO_STATS(lzo_stats->literals += t);
             LZO_STATS(lzo_stats->r0short_runs++);
-                *op++ = 0; *op++ = LZO_BYTE(t - R0MIN);
+            *op++ = 0;
+            *op++ = LZO_BYTE(t - R0MIN);
             MEMCPY_DS(op, ii, t);
 #if defined(LZO_HAVE_R1)
             r1 = ip + (M2_MIN_LEN + 1);     /* set new R1 pointer */
@@ -99,14 +104,14 @@
         }
         else
         {
-                op = STORE_RUN(op,ii,t);
+            op = STORE_RUN(op, ii, t);
             ii = ip;
         }
-        }
+}
 
 
-        /* ii now points to the start of the current match */
-        assert(ii == ip);
+/* ii now points to the start of the current match */
+assert(ii == ip);
 
 
 /* vim:set ts=4 sw=4 et: */

extern/lzo/src/lzo1b_d.ch

@@ -34,9 +34,9 @@
 ************************************************************************/
 
 LZO_PUBLIC(int)
-DO_DECOMPRESS    ( const lzo_bytep in , lzo_uint  in_len,
+DO_DECOMPRESS(const lzo_bytep in , lzo_uint  in_len,
               lzo_bytep out, lzo_uintp out_len,
-                         lzo_voidp wrkmem )
+              lzo_voidp wrkmem)
 {
     lzo_bytep op;
     const lzo_bytep ip;
@@ -63,9 +63,11 @@ DO_DECOMPRESS    ( const lzo_bytep in , lzo_uint  in_len,
             {
                 NEED_IP(1);
                 t = *ip++;
+
                 if (t >= R0FAST - R0MIN)            /* a long R0 run */
                 {
                     t -= R0FAST - R0MIN;
+
                     if (t == 0)
                         t = R0FAST;
                     else
@@ -75,37 +77,57 @@ DO_DECOMPRESS    ( const lzo_bytep in , lzo_uint  in_len,
 #else
                         /* help the optimizer */
                         lzo_uint tt = 256;
-                        do tt <<= 1; while (--t > 0);
+
+                        do tt <<= 1;
+
+                        while (--t > 0);
+
                         t = tt;
 #endif
                     }
 
-                    NEED_IP(t); NEED_OP(t);
+                    NEED_IP(t);
+                    NEED_OP(t);
 #if 1 && (LZO_OPT_UNALIGNED32)
-                    do {
-                        UA_COPY4(op+0, ip+0);
-                        UA_COPY4(op+4, ip+4);
-                        op += 8; ip += 8;
+
+                    do
+                    {
+                        UA_COPY4(op + 0, ip + 0);
+                        UA_COPY4(op + 4, ip + 4);
+                        op += 8;
+                        ip += 8;
                         t -= 8;
-                    } while (t > 0);
+                    }
+                    while (t > 0);
+
 #else
-                    MEMCPY8_DS(op,ip,t);
+                    MEMCPY8_DS(op, ip, t);
 #endif
                     continue;
                 }
+
                 t += R0MIN;                         /* a short R0 run */
             }
 
-            NEED_IP(t); NEED_OP(t);
+            NEED_IP(t);
+            NEED_OP(t);
             /* copy literal run */
 #if 1 && (LZO_OPT_UNALIGNED32)
+
             if (t >= 4)
             {
-                do {
+                do
+                {
                     UA_COPY4(op, ip);
-                    op += 4; ip += 4; t -= 4;
-                } while (t >= 4);
-                if (t > 0) do *op++ = *ip++; while (--t > 0);
+                    op += 4;
+                    ip += 4;
+                    t -= 4;
+                }
+                while (t >= 4);
+
+                if (t > 0) do* op++ = *ip++;
+
+                    while (--t > 0);
             }
             else
 #endif
@@ -113,7 +135,10 @@ DO_DECOMPRESS    ( const lzo_bytep in , lzo_uint  in_len,
 #if (M3O_BITS < 7)
 literal1:
 #endif
-                do *op++ = *ip++; while (--t > 0);
+
+                do* op++ = *ip++;
+
+                while (--t > 0);
             }
 
 #if (M3O_BITS == 7)
@@ -124,16 +149,19 @@ literal2:
             while (TEST_IP_AND_TEST_OP)
             {
                 t = *ip++;          /* get R1 marker */
+
                 if (t >= R0MIN)
                     goto match;
 
-                NEED_IP(2); NEED_OP(M2_MIN_LEN + 1);
+                NEED_IP(2);
+                NEED_OP(M2_MIN_LEN + 1);
 
                 /* R1 match - a M2_MIN_LEN match + 1 byte literal */
                 assert((t & M2O_MASK) == t);
                 m_pos = op - M2_MIN_OFFSET;
-                m_pos -= t | (((lzo_uint) *ip++) << M2O_BITS);
-                assert(m_pos >= out); assert(m_pos < op);
+                m_pos -= t | (((lzo_uint) * ip++) << M2O_BITS);
+                assert(m_pos >= out);
+                assert(m_pos < op);
                 TEST_LB(m_pos);
                 COPY_M2;
                 *op++ = *ip++;
@@ -151,23 +179,26 @@ match:
             /* get match offset */
             NEED_IP(1);
             m_pos = op - M2_MIN_OFFSET;
-            m_pos -= (t & M2O_MASK) | (((lzo_uint) *ip++) << M2O_BITS);
-            assert(m_pos >= out); assert(m_pos < op);
+            m_pos -= (t & M2O_MASK) | (((lzo_uint) * ip++) << M2O_BITS);
+            assert(m_pos >= out);
+            assert(m_pos < op);
             TEST_LB(m_pos);
 
             /* get match len */
             t = (t >> M2O_BITS) - 1;
             NEED_OP(t + M2_MIN_LEN - 1);
             COPY_M2X;
-            MEMCPY_DS(op,m_pos,t);
+            MEMCPY_DS(op, m_pos, t);
         }
         else                            /* a M3 or M4 match */
         {
             /* get match len */
             t &= M3L_MASK;
+
             if (t == 0)         /* a M4 match */
             {
                 NEED_IP(1);
+
                 while (*ip == 0)
                 {
                     t += 255;
@@ -175,6 +206,7 @@ match:
                     TEST_OV(t);
                     NEED_IP(1);
                 }
+
                 t += (M4_MIN_LEN - M3_MIN_LEN) + *ip++;
             }
 
@@ -184,47 +216,68 @@ match:
             m_pos -= *ip++ & M3O_MASK;
             m_pos -= (lzo_uint)(*ip++) << M3O_BITS;
 #if defined(LZO_EOF_CODE)
+
             if (m_pos == op)
                 goto eof_found;
+
 #endif
 
             /* copy match */
-            assert(m_pos >= out); assert(m_pos < op);
-            TEST_LB(m_pos); NEED_OP(t + M3_MIN_LEN - 1);
+            assert(m_pos >= out);
+            assert(m_pos < op);
+            TEST_LB(m_pos);
+            NEED_OP(t + M3_MIN_LEN - 1);
 #if (LZO_OPT_UNALIGNED32)
+
             if (t >= 2 * 4 - (M3_MIN_LEN - 1) && (op - m_pos) >= 4)
             {
                 UA_COPY4(op, m_pos);
-                op += 4; m_pos += 4; t -= 4 - (M3_MIN_LEN - 1);
-                do {
+                op += 4;
+                m_pos += 4;
+                t -= 4 - (M3_MIN_LEN - 1);
+
+                do
+                {
                     UA_COPY4(op, m_pos);
-                    op += 4; m_pos += 4; t -= 4;
-                } while (t >= 4);
-                if (t > 0) do *op++ = *m_pos++; while (--t > 0);
+                    op += 4;
+                    m_pos += 4;
+                    t -= 4;
+                }
+                while (t >= 4);
+
+                if (t > 0) do* op++ = *m_pos++;
+
+                    while (--t > 0);
             }
             else
 #endif
             {
                 COPY_M3X;
-            MEMCPY_DS(op,m_pos,t);
+                MEMCPY_DS(op, m_pos, t);
             }
 
 
 #if (M3O_BITS < 7)
             t = ip[-2] >> M3O_BITS;
+
             if (t)
             {
-                NEED_IP(t); NEED_OP(t);
+                NEED_IP(t);
+                NEED_OP(t);
                 goto literal1;
             }
+
 #elif (M3O_BITS == 7)
+
             /* optimized version */
             if (ip[-2] & (1 << M3O_BITS))
             {
-                NEED_IP(1); NEED_OP(1);
+                NEED_IP(1);
+                NEED_OP(1);
                 *op++ = *ip++;
                 goto literal2;
             }
+
 #endif
         }
     }

extern/lzo/src/lzo1b_r.ch

@@ -30,8 +30,8 @@
 // store a literal run (internal)
 ************************************************************************/
 
-LZO_LOCAL_IMPL(lzo_bytep )
-STORE_RUN ( lzo_bytep const oo, const lzo_bytep const ii, lzo_uint r_len)
+LZO_LOCAL_IMPL(lzo_bytep)
+STORE_RUN(lzo_bytep const oo, const lzo_bytep const ii, lzo_uint r_len)
 {
     lzo_bytep op;
     const lzo_bytep ip;
@@ -52,37 +52,48 @@ STORE_RUN ( lzo_bytep const oo, const lzo_bytep const ii, lzo_uint r_len)
         while (r_len >= (t = tt))
         {
             r_len -= t;
-            *op++ = 0; *op++ = (R0FAST - R0MIN) + 7;
+            *op++ = 0;
+            *op++ = (R0FAST - R0MIN) + 7;
             MEMCPY8_DS(op, ip, t);
             LZO_STATS(lzo_stats->r0long_runs++);
         }
+
         tt >>= 1;
-        do {
+
+        do
+        {
             if (r_len >= (t = tt))
             {
                 r_len -= t;
-                *op++ = 0; *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits);
+                *op++ = 0;
+                *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits);
                 MEMCPY8_DS(op, ip, t);
                 LZO_STATS(lzo_stats->r0long_runs++);
             }
+
             tt >>= 1;
-        } while (--r_bits > 0);
         }
+        while (--r_bits > 0);
+    }
+
     assert(r_len < 512);
 
     while (r_len >= (t = R0FAST))
     {
         r_len -= t;
-        *op++ = 0; *op++ = (R0FAST - R0MIN);
+        *op++ = 0;
+        *op++ = (R0FAST - R0MIN);
         MEMCPY8_DS(op, ip, t);
         LZO_STATS(lzo_stats->r0fast_runs++);
     }
 
     t = r_len;
+
     if (t >= R0MIN)
     {
         /* code a short R0 run */
-        *op++ = 0; *op++ = LZO_BYTE(t - R0MIN);
+        *op++ = 0;
+        *op++ = LZO_BYTE(t - R0MIN);
         MEMCPY_DS(op, ip, t);
         LZO_STATS(lzo_stats->r0short_runs++);
     }

extern/lzo/src/lzo1b_sm.ch

@@ -39,41 +39,50 @@
 
 #if (DD_BITS == 0)
 
-        /* search ip in the dictionary */
-        DINDEX1(dindex,ip);
-        GINDEX(m_pos,m_off,dict,dindex,in);
-        if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M3_MAX_OFFSET))
+/* search ip in the dictionary */
+DINDEX1(dindex, ip);
+GINDEX(m_pos, m_off, dict, dindex, in);
+
+if (LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, M3_MAX_OFFSET))
     goto literal;
+
 #if 1
-        if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
+
+if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
     goto try_match;
-        DINDEX2(dindex,ip);
+
+DINDEX2(dindex, ip);
 #endif
-        GINDEX(m_pos,m_off,dict,dindex,in);
-        if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M3_MAX_OFFSET))
+GINDEX(m_pos, m_off, dict, dindex, in);
+
+if (LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, M3_MAX_OFFSET))
     goto literal;
-        if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
+
+if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
     goto try_match;
-        goto literal;
+
+goto literal;
 
 
 #else /* (DD_BITS == 0) */
 
 
 
-        /* search ip in the deepened dictionary */
-        {
-            lzo_dict_p d = &dict [ DINDEX(dv,ip) ];
+/* search ip in the deepened dictionary */
+{
+    lzo_dict_p d = &dict [ DINDEX(dv, ip) ];
     const lzo_bytep ip_sav;
     unsigned j = DD_SIZE;
     lzo_uint x_len;
     LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, x_off, 0);
 
-            DVAL_ASSERT(dv,ip);
+    DVAL_ASSERT(dv, ip);
 
     ip_sav = ip;
     m_len = 0;
-            do {
+
+    do
+    {
 #if !defined(NDEBUG)
         const lzo_bytep z_pos = NULL;
 #endif
@@ -89,9 +98,10 @@
 #endif
         assert(ip == ip_sav);
 
-                if (LZO_CHECK_MPOS(m_pos,x_off,in,ip,MAX_OFFSET))
+        if (LZO_CHECK_MPOS(m_pos, x_off, in, ip, MAX_OFFSET))
 #if (CLEVEL == 9)
-                    *d = DENTRY(ip,in);
+            *d = DENTRY(ip, in);
+
 #else
             ((void)(0));
 #endif
@@ -102,16 +112,19 @@
 #if !(LZO_DICT_USE_PTR)
             assert((z_pos = ip - 3 - x_off) == (m_pos - 3));
 #endif
+
             /* a match */
             if (MATCH_M2)
             {
                 x_len = pd((ip - 1), ip_sav);
+
                 if (x_len > m_len)
                 {
                     m_len = x_len;
                     m_off = x_off;
                     assert((m_pos_sav = z_pos) != NULL);
                 }
+
 #if (CLEVEL == 9)
                 /* try to find a closer match */
                 else if (x_len == m_len && x_off < m_off)
@@ -119,6 +132,7 @@
                     m_off = x_off;
                     assert((m_pos_sav = z_pos) != NULL);
                 }
+
 #endif
             }
             else
@@ -129,24 +143,28 @@
                 {
                     const lzo_bytep end;
                     end = MATCH_IP_END;
+
                     while (ip < end  &&  *m_pos == *ip)
                         m_pos++, ip++;
+
                     assert(ip <= in_end);
                     x_len = pd(ip, ip_sav);
                 }
+
                 if (x_len > m_len)
                 {
                     m_len = x_len;
                     m_off = x_off;
                     assert((m_pos_sav = z_pos) != NULL);
+
                     if (ip >= MATCH_IP_END)
                     {
                         ip = ip_sav;
 #if 0
                         /* not needed - we are at the end */
                         d -= DD_SIZE - j;
-                                assert(d == &dict [ DINDEX(dv,ip) ]);
-                                UPDATE_P(d,drun,ip,in);
+                        assert(d == &dict [ DINDEX(dv, ip) ]);
+                        UPDATE_P(d, drun, ip, in);
 #endif
                         goto match;
                     }
@@ -156,7 +174,9 @@
                     m_off = x_off;
                     assert((m_pos_sav = z_pos) != NULL);
                 }
+
 #else
+
                 /* try to find a closer match */
                 if (m_len < M2_MAX_LEN + 1 || x_off < m_off)
                 {
@@ -164,6 +184,7 @@
                     m_off = x_off;
                     assert((m_pos_sav = z_pos) != NULL);
                 }
+
 #endif
 #else
                 /* don't search for a longer/closer match */
@@ -172,23 +193,27 @@
                 assert((m_pos_sav = z_pos) != NULL);
                 ip = ip_sav;
                 d -= DD_SIZE - j;
-                        assert(d == &dict [ DINDEX(dv,ip) ]);
-                        UPDATE_P(d,drun,ip,in);
+                assert(d == &dict [ DINDEX(dv, ip) ]);
+                UPDATE_P(d, drun, ip, in);
                 goto match;
 #endif
             }
+
             ip = ip_sav;
         }
         else
             ip = ip_sav;
+
         d++;
-            } while (--j > 0);
+    }
+    while (--j > 0);
+
     assert(ip == ip_sav);
 
     d -= DD_SIZE;
-            assert(d == &dict [ DINDEX(dv,ip) ]);
-            UPDATE_P(d,drun,ip,in);
-        }
+    assert(d == &dict [ DINDEX(dv, ip) ]);
+    UPDATE_P(d, drun, ip, in);
+}
 
 #endif /* (DD_BITS == 0) */
 

extern/lzo/src/lzo1b_tm.ch

@@ -43,39 +43,46 @@
 try_match:
 #if !defined(NDEBUG) && (LZO_DICT_USE_PTR)
 #if (LZO_DETERMINISTIC)
-        assert(m_pos == NULL || m_pos >= in);
-        assert(m_pos == NULL || m_pos < ip);
+assert(m_pos == NULL || m_pos >= in);
+assert(m_pos == NULL || m_pos < ip);
 #endif
-        m_pos_sav = m_pos;
+m_pos_sav = m_pos;
 #endif
-        if (m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2])
-        {
+
+if (m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2])
+{
     m_pos += 3;
     goto match;
-        }
+}
 
 
 #else /* (DD_BITS == 0) */
 
 
-    /* test potential match */
+/* test potential match */
 
-        if (m_len > M2_MIN_LEN)
+if (m_len > M2_MIN_LEN)
     goto match;
-        if (m_len == M2_MIN_LEN)
-        {
+
+if (m_len == M2_MIN_LEN)
+{
 #if (_MAX_OFFSET == _M2_MAX_OFFSET)
     goto match;
 #else
+
     if (m_off <= M2_MAX_OFFSET)
         goto match;
+
 #if 0 && (M3_MIN_LEN == M2_MIN_LEN)
+
     if (ip == ii)
         goto match;
+
 #endif
 #endif
-        }
-        goto literal;
+}
+
+goto literal;
 
 
 #endif /* (DD_BITS == 0) */

extern/lzo/src/lzo1b_xx.c

@@ -33,7 +33,7 @@
 //
 ************************************************************************/
 
-static const lzo_compress_t * const c_funcs [9] =
+static const lzo_compress_t* const c_funcs [9] =
 {
     &_lzo1b_1_compress_func,
     &_lzo1b_2_compress_func,
@@ -49,7 +49,7 @@ static const lzo_compress_t * const c_funcs [9] =
 
 static lzo_compress_t lzo1b_get_compress_func(int clevel)
 {
-    const lzo_compress_t *f;
+    const lzo_compress_t* f;
 
     if (clevel < LZO1B_BEST_SPEED || clevel > LZO1B_BEST_COMPRESSION)
     {
@@ -58,24 +58,27 @@ static lzo_compress_t lzo1b_get_compress_func(int clevel)
         else
             return (lzo_compress_t) 0;
     }
-    f = c_funcs[clevel-1];
+
+    f = c_funcs[clevel - 1];
     assert(f && *f);
     return *f;
 }
 
 
 LZO_PUBLIC(int)
-lzo1b_compress ( const lzo_bytep src, lzo_uint  src_len,
+lzo1b_compress(const lzo_bytep src, lzo_uint  src_len,
                lzo_bytep dst, lzo_uintp dst_len,
                lzo_voidp wrkmem,
-                       int clevel )
+               int clevel)
 {
     lzo_compress_t f;
 
     f = lzo1b_get_compress_func(clevel);
+
     if (!f)
         return LZO_E_ERROR;
-    return _lzo1b_do_compress(src,src_len,dst,dst_len,wrkmem,f);
+
+    return _lzo1b_do_compress(src, src_len, dst, dst_len, wrkmem, f);
 }
 
 

extern/lzo/src/lzo1c_9x.c

@@ -50,7 +50,7 @@
 ************************************************************************/
 
 static lzo_bytep
-code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
+code_match(LZO_COMPRESS_T* c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off)
 {
     if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
     {
@@ -71,6 +71,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
         assert(m_off <= M3_MAX_OFFSET);
 
         m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET;
+
         /* code match len */
         if (m_len <= M3_MAX_LEN)
             *op++ = LZO_BYTE(M3_MARKER | (m_len - (M3_MIN_LEN - 1)));
@@ -81,14 +82,17 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
             *op++ = M4_MARKER;
             /* code match len */
             m_len -= M4_MIN_LEN - 1;
+
             while (m_len > 255)
             {
                 m_len -= 255;
                 *op++ = 0;
             }
+
             assert(m_len > 0);
             *op++ = LZO_BYTE(m_len);
         }
+
         /* code low offset bits */
         *op++ = LZO_BYTE(m_off & M3O_MASK);
         /* code high offset bits */
@@ -98,6 +102,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
         c->m3 = op;
         c->m3_m++;
     }
+
     return op;
 }
 
@@ -107,25 +112,25 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
 ************************************************************************/
 
 LZO_EXTERN(int)
-lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
+lzo1c_999_compress_callback(const lzo_bytep in , lzo_uint  in_len,
                             lzo_bytep out, lzo_uintp out_len,
                             lzo_voidp wrkmem,
                             lzo_callback_p cb,
-                                    lzo_uint max_chain );
+                            lzo_uint max_chain);
 
 LZO_PUBLIC(int)
-lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
+lzo1c_999_compress_callback(const lzo_bytep in , lzo_uint  in_len,
                             lzo_bytep out, lzo_uintp out_len,
                             lzo_voidp wrkmem,
                             lzo_callback_p cb,
-                                    lzo_uint max_chain )
+                            lzo_uint max_chain)
 {
     lzo_bytep op;
     const lzo_bytep ii;
     lzo_uint lit;
     lzo_uint m_len, m_off;
     LZO_COMPRESS_T cc;
-    LZO_COMPRESS_T * const c = &cc;
+    LZO_COMPRESS_T* const c = &cc;
     lzo_swd_p const swd = (lzo_swd_p) wrkmem;
     int r;
 
@@ -144,15 +149,19 @@ lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
     c->r1_m_len = 0;
     c->m3 = out + 1;        /* pointer after last m3/m4 match */
 
-    r = init_match(c,swd,NULL,0,0);
+    r = init_match(c, swd, NULL, 0, 0);
+
     if (r != 0)
         return r;
+
     if (max_chain > 0)
         swd->max_chain = max_chain;
 
-    r = find_match(c,swd,0,0);
+    r = find_match(c, swd, 0, 0);
+
     if (r != 0)
         return r;
+
     while (c->look > 0)
     {
         int lazy_match_min_gain = -1;
@@ -162,13 +171,15 @@ lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
         m_off = c->m_off;
 
 #if 0
-        printf("%5ld: %5d len:%3d off:%5d\n", (c->ip-c->look)-in, c->look,
+        printf("%5ld: %5d len:%3d off:%5d\n", (c->ip - c->look) - in, c->look,
                m_len, m_off);
 #endif
 
         assert(c->ip - c->look >= in);
+
         if (lit == 0)
             ii = c->ip - c->look;
+
         assert(ii + lit == c->ip - c->look);
         assert(swd->b_char == *(c->ip - c->look));
 
@@ -198,20 +209,24 @@ lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
                     lazy_match_min_gain = 1;
 
 #if (M2_MIN_LEN == 2)
+
                 if (m_len == 2)
                 {
                     /* don't code a match of len 2 if we have to
                        code a literal run. Code a literal instead. */
                     m_len = 0;
                 }
+
 #endif
 #if (M2_MIN_LEN == M3_MIN_LEN)
+
                 if (m_len == M2_MIN_LEN && m_off > M2_MAX_OFFSET)
                 {
                     /* don't code a M3 match of len 3 if we have to
                        code a literal run. Code a literal instead. */
                     m_len = 0;
                 }
+
 #endif
             }
             else
@@ -229,12 +244,14 @@ lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
         /* try a lazy match */
         if (m_len == 0)
             lazy_match_min_gain = -1;
+
         if (lazy_match_min_gain >= 0 && c->look > m_len)
         {
             assert(m_len > 0);
 
-            r = find_match(c,swd,1,0);
-            assert(r == 0); LZO_UNUSED(r);
+            r = find_match(c, swd, 1, 0);
+            assert(r == 0);
+            LZO_UNUSED(r);
             assert(c->look > 0);
 
             if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET &&
@@ -259,8 +276,10 @@ lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
                 ahead = 1;
                 assert(ii + lit + 1 == c->ip - c->look);
             }
+
             assert(m_len > 0);
         }
+
         assert(ii + lit + ahead == c->ip - c->look);
 
 
@@ -268,8 +287,9 @@ lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
         {
             /* a literal */
             lit++;
-            r = find_match(c,swd,1,0);
-            assert(r == 0); LZO_UNUSED(r);
+            r = find_match(c, swd, 1, 0);
+            assert(r == 0);
+            LZO_UNUSED(r);
         }
         else
         {
@@ -298,21 +318,24 @@ lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
                 }
                 else
                 {
-                    op = STORE_RUN(op,ii,lit);
+                    op = STORE_RUN(op, ii, lit);
                 }
+
                 if (lit < R0FAST)
                     c->r1_m_len = m_len;
                 else
                     c->r1_m_len = 0;
+
                 lit = 0;
             }
             else
                 c->r1_m_len = 0;
 
             /* 2 - code match */
-            op = code_match(c,op,m_len,m_off);
-            r = find_match(c,swd,m_len,1+ahead);
-            assert(r == 0); LZO_UNUSED(r);
+            op = code_match(c, op, m_len, m_off);
+            r = find_match(c, swd, m_len, 1 + ahead);
+            assert(r == 0);
+            LZO_UNUSED(r);
         }
 
         c->codesize = pd(op, out);
@@ -321,7 +344,7 @@ lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
 
     /* store final run */
     if (lit > 0)
-        op = STORE_RUN(op,ii,lit);
+        op = STORE_RUN(op, ii, lit);
 
 #if defined(LZO_EOF_CODE)
     *op++ = M3_MARKER | 1;
@@ -352,11 +375,11 @@ lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
 ************************************************************************/
 
 LZO_PUBLIC(int)
-lzo1c_999_compress  ( const lzo_bytep in , lzo_uint  in_len,
+lzo1c_999_compress(const lzo_bytep in , lzo_uint  in_len,
                    lzo_bytep out, lzo_uintp out_len,
-                            lzo_voidp wrkmem )
+                   lzo_voidp wrkmem)
 {
-    return lzo1c_999_compress_callback(in,in_len,out,out_len,wrkmem,
+    return lzo1c_999_compress_callback(in, in_len, out, out_len, wrkmem,
                                        (lzo_callback_p) 0, 0);
 }
 

extern/lzo/src/lzo1c_cc.c

@@ -35,10 +35,10 @@
 ************************************************************************/
 
 LZO_LOCAL_IMPL(int)
-_lzo1c_do_compress ( const lzo_bytep in,  lzo_uint  in_len,
+_lzo1c_do_compress(const lzo_bytep in,  lzo_uint  in_len,
                    lzo_bytep out, lzo_uintp out_len,
                    lzo_voidp wrkmem,
-                           lzo_compress_t func )
+                   lzo_compress_t func)
 {
     int r;
 #if defined(LZO_TEST_COMPRESS_OVERRUN)
@@ -64,19 +64,22 @@ _lzo1c_do_compress ( const lzo_bytep in,  lzo_uint  in_len,
         *out_len = 0;
         r = LZO_E_NOT_COMPRESSIBLE;
 #else
-        *out_len = pd(STORE_RUN(out,in,in_len), out);
+        *out_len = pd(STORE_RUN(out, in, in_len), out);
         r = (*out_len > in_len) ? LZO_E_OK : LZO_E_ERROR;
 #endif
     }
     else
-        r = func(in,in_len,out,out_len,wrkmem);
+        r = func(in, in_len, out, out_len, wrkmem);
 
 
 #if defined(LZO_EOF_CODE)
 #if defined(LZO_TEST_COMPRESS_OVERRUN)
+
     if (r == LZO_E_OK && avail_out - *out_len < 3)
         r = LZO_E_COMPRESS_OVERRUN;
+
 #endif
+
     if (r == LZO_E_OK)
     {
         lzo_bytep op = out + *out_len;
@@ -85,6 +88,7 @@ _lzo1c_do_compress ( const lzo_bytep in,  lzo_uint  in_len,
         op[2] = 0;
         *out_len += 3;
     }
+
 #endif
 
 
@@ -112,16 +116,16 @@ _lzo1c_do_compress ( const lzo_bytep in,  lzo_uint  in_len,
 #if (LZO_COLLECT_STATS)
 
 static lzo_stats_t lzo_statistics;
-lzo_stats_t * const lzo1c_stats = &lzo_statistics;
+lzo_stats_t* const lzo1c_stats = &lzo_statistics;
 
 
-void _lzo1c_stats_init(lzo_stats_t *lzo_stats)
+void _lzo1c_stats_init(lzo_stats_t* lzo_stats)
 {
-    lzo_memset(lzo_stats,0,sizeof(*lzo_stats));
+    lzo_memset(lzo_stats, 0, sizeof(*lzo_stats));
 }
 
 
-void _lzo1c_stats_calc(lzo_stats_t *lzo_stats)
+void _lzo1c_stats_calc(lzo_stats_t* lzo_stats)
 {
     lzo_stats->matches =
         lzo_stats->m1_matches + lzo_stats->m2_matches +

extern/lzo/src/lzo1c_cc.h

@@ -57,18 +57,18 @@ extern const lzo_compress_t _lzo1c_99_compress_func;
 //
 ************************************************************************/
 
-LZO_LOCAL_DECL(lzo_bytep )
-_lzo1c_store_run ( lzo_bytep const oo, const lzo_bytep const ii,
+LZO_LOCAL_DECL(lzo_bytep)
+_lzo1c_store_run(lzo_bytep const oo, const lzo_bytep const ii,
                  lzo_uint r_len);
 
 #define STORE_RUN   _lzo1c_store_run
 
 
 LZO_LOCAL_DECL(int)
-_lzo1c_do_compress ( const lzo_bytep in,  lzo_uint  in_len,
+_lzo1c_do_compress(const lzo_bytep in,  lzo_uint  in_len,
                    lzo_bytep out, lzo_uintp out_len,
                    lzo_voidp wrkmem,
-                           lzo_compress_t func );
+                   lzo_compress_t func);
 
 
 #endif /* already included */

extern/lzo/src/lzo1c_d2.c

@@ -35,11 +35,11 @@
 
 #if defined(LZO_ARCH_I386) && defined(LZO_USE_ASM)
 LZO_EXTERN(int) lzo1c_decompress_asm_safe
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem);
 LZO_PUBLIC(int) lzo1c_decompress_asm_safe
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem)
 {

extern/lzo/src/lzo1c_xx.c

@@ -33,7 +33,7 @@
 //
 ************************************************************************/
 
-static const lzo_compress_t * const c_funcs [9] =
+static const lzo_compress_t* const c_funcs [9] =
 {
     &_lzo1c_1_compress_func,
     &_lzo1c_2_compress_func,
@@ -49,7 +49,7 @@ static const lzo_compress_t * const c_funcs [9] =
 
 static lzo_compress_t lzo1c_get_compress_func(int clevel)
 {
-    const lzo_compress_t *f;
+    const lzo_compress_t* f;
 
     if (clevel < LZO1C_BEST_SPEED || clevel > LZO1C_BEST_COMPRESSION)
     {
@@ -58,24 +58,27 @@ static lzo_compress_t lzo1c_get_compress_func(int clevel)
         else
             return (lzo_compress_t) 0;
     }
-    f = c_funcs[clevel-1];
+
+    f = c_funcs[clevel - 1];
     assert(f && *f);
     return *f;
 }
 
 
 LZO_PUBLIC(int)
-lzo1c_compress ( const lzo_bytep src, lzo_uint  src_len,
+lzo1c_compress(const lzo_bytep src, lzo_uint  src_len,
                lzo_bytep dst, lzo_uintp dst_len,
                lzo_voidp wrkmem,
-                       int clevel )
+               int clevel)
 {
     lzo_compress_t f;
 
     f = lzo1c_get_compress_func(clevel);
+
     if (!f)
         return LZO_E_ERROR;
-    return _lzo1c_do_compress(src,src_len,dst,dst_len,wrkmem,f);
+
+    return _lzo1c_do_compress(src, src_len, dst, dst_len, wrkmem, f);
 }
 
 

extern/lzo/src/lzo1f_1.c

@@ -53,9 +53,9 @@
 ************************************************************************/
 
 static __lzo_noinline
-int do_compress          ( const lzo_bytep in , lzo_uint  in_len,
+int do_compress(const lzo_bytep in , lzo_uint  in_len,
                 lzo_bytep out, lzo_uintp out_len,
-                                 lzo_voidp wrkmem )
+                lzo_voidp wrkmem)
 {
     const lzo_bytep ip;
     lzo_bytep op;
@@ -69,6 +69,7 @@ int do_compress          ( const lzo_bytep in , lzo_uint  in_len,
     ii = ip;
 
     ip++;
+
     for (;;)
     {
         const lzo_bytep m_pos;
@@ -77,25 +78,33 @@ int do_compress          ( const lzo_bytep in , lzo_uint  in_len,
         lzo_uint dindex;
         lzo_uint lit;
 
-        DINDEX1(dindex,ip);
-        GINDEX(m_pos,m_off,dict,dindex,in);
-        if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M3_MAX_OFFSET))
+        DINDEX1(dindex, ip);
+        GINDEX(m_pos, m_off, dict, dindex, in);
+
+        if (LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, M3_MAX_OFFSET))
             goto literal;
+
 #if 1
+
         if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
             goto try_match;
-        DINDEX2(dindex,ip);
+
+        DINDEX2(dindex, ip);
 #endif
-        GINDEX(m_pos,m_off,dict,dindex,in);
-        if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M3_MAX_OFFSET))
+        GINDEX(m_pos, m_off, dict, dindex, in);
+
+        if (LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, M3_MAX_OFFSET))
             goto literal;
+
         if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
             goto try_match;
+
         goto literal;
 
 
 try_match:
 #if 0 && (LZO_OPT_UNALIGNED16)
+
         if (UA_GET_NE16(m_pos) != UA_GET_NE16(ip))
 #else
         if (m_pos[0] != ip[0] || m_pos[1] != ip[1])
@@ -108,16 +117,23 @@ try_match:
             {
                 m_pos += 3;
 #if 0
+
                 if (m_off <= M2_MAX_OFFSET)
                     goto match;
+
                 if (lit <= 3)
                     goto match;
+
                 if (lit == 3)           /* better compression, but slower */
                 {
-                    assert(op - 2 > out); op[-2] |= LZO_BYTE(3);
-                    *op++ = *ii++; *op++ = *ii++; *op++ = *ii++;
+                    assert(op - 2 > out);
+                    op[-2] |= LZO_BYTE(3);
+                    *op++ = *ii++;
+                    *op++ = *ii++;
+                    *op++ = *ii++;
                     goto code_match;
                 }
+
                 if (*m_pos == ip[3])
 #endif
                     goto match;
@@ -127,17 +143,20 @@ try_match:
 
         /* a literal */
 literal:
-        UPDATE_I(dict,0,dindex,ip,in);
+        UPDATE_I(dict, 0, dindex, ip, in);
+
         if (++ip >= ip_end)
             break;
+
         continue;
 
 
         /* a match */
 match:
-        UPDATE_I(dict,0,dindex,ip,in);
+        UPDATE_I(dict, 0, dindex, ip, in);
         /* store current literal run */
-        lit = pd(ip,ii);
+        lit = pd(ip, ii);
+
         if (lit > 0)
         {
             lzo_uint t = lit;
@@ -151,28 +170,36 @@ match:
                 lzo_uint tt = t - 31;
 
                 *op++ = 0;
+
                 while (tt > 255)
                 {
                     tt -= 255;
                     UA_SET1(op, 0);
                     op++;
                 }
+
                 assert(tt > 0);
                 *op++ = LZO_BYTE(tt);
             }
-            do *op++ = *ii++; while (--t > 0);
+
+            do* op++ = *ii++;
+
+            while (--t > 0);
         }
+
         assert(ii == ip);
 
 
         /* code the match */
         ip += 3;
+
         if (*m_pos++ != *ip++ || *m_pos++ != *ip++ || *m_pos++ != *ip++ ||
                 *m_pos++ != *ip++ || *m_pos++ != *ip++ || *m_pos++ != *ip++)
         {
             --ip;
             m_len = pd(ip, ii);
-            assert(m_len >= 3); assert(m_len <= 8);
+            assert(m_len >= 3);
+            assert(m_len <= 8);
 
             if (m_off <= M2_MAX_OFFSET)
             {
@@ -180,7 +207,7 @@ match:
                 *op++ = LZO_BYTE(((m_len - 2) << 5) | ((m_off & 7) << 2));
                 *op++ = LZO_BYTE(m_off >> 3);
             }
-            else if (m_len == 3 && m_off <= 2*M2_MAX_OFFSET && lit > 0)
+            else if (m_len == 3 && m_off <= 2 * M2_MAX_OFFSET && lit > 0)
             {
                 m_off -= 1;
                 /* m_off -= M2_MAX_OFFSET; */
@@ -199,8 +226,10 @@ match:
             {
                 const lzo_bytep end;
                 end = in_end;
+
                 while (ip < end && *m_pos == *ip)
                     m_pos++, ip++;
+
                 m_len = pd(ip, ii);
             }
             assert(m_len >= 3);
@@ -211,29 +240,33 @@ match:
             {
                 m_len -= 33;
                 *op++ = M3_MARKER | 0;
+
                 while (m_len > 255)
                 {
                     m_len -= 255;
                     UA_SET1(op, 0);
                     op++;
                 }
+
                 assert(m_len > 0);
                 *op++ = LZO_BYTE(m_len);
             }
+
             *op++ = LZO_BYTE((m_off & 63) << 2);
             *op++ = LZO_BYTE(m_off >> 6);
         }
 
         ii = ip;
+
         if (ip >= ip_end)
             break;
     }
 
 
     /* store final literal run */
-    if (pd(in_end,ii) > 0)
+    if (pd(in_end, ii) > 0)
     {
-        lzo_uint t = pd(in_end,ii);
+        lzo_uint t = pd(in_end, ii);
 
         if (t < 4 && op > out)
             op[-2] = LZO_BYTE(op[-2] | t);
@@ -244,15 +277,18 @@ match:
             lzo_uint tt = t - 31;
 
             *op++ = 0;
+
             while (tt > 255)
             {
                 tt -= 255;
                 UA_SET1(op, 0);
                 op++;
             }
+
             assert(tt > 0);
             *op++ = LZO_BYTE(tt);
         }
+
         UA_COPYN(op, ii, t);
         op += t;
     }
@@ -267,9 +303,9 @@ match:
 ************************************************************************/
 
 LZO_PUBLIC(int)
-lzo1f_1_compress ( const lzo_bytep in , lzo_uint  in_len,
+lzo1f_1_compress(const lzo_bytep in , lzo_uint  in_len,
                  lzo_bytep out, lzo_uintp out_len,
-                         lzo_voidp wrkmem )
+                 lzo_voidp wrkmem)
 {
     lzo_bytep op = out;
     int r = LZO_E_OK;
@@ -279,11 +315,15 @@ lzo1f_1_compress ( const lzo_bytep in , lzo_uint  in_len,
     else if (in_len <= 10)
     {
         *op++ = LZO_BYTE(in_len);
-        do *op++ = *in++; while (--in_len > 0);
+
+        do* op++ = *in++;
+
+        while (--in_len > 0);
+
         *out_len = pd(op, out);
     }
     else
-        r = do_compress(in,in_len,out,out_len,wrkmem);
+        r = do_compress(in, in_len, out, out_len, wrkmem);
 
     if (r == LZO_E_OK)
     {

extern/lzo/src/lzo1f_9x.c

@@ -50,7 +50,7 @@
 ************************************************************************/
 
 static lzo_bytep
-code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
+code_match(LZO_COMPRESS_T* c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off)
 {
     if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
     {
@@ -76,14 +76,17 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
         {
             m_len -= M3_MAX_LEN;
             *op++ = M3_MARKER | 0;
+
             while (m_len > 255)
             {
                 m_len -= 255;
                 *op++ = 0;
             }
+
             assert(m_len > 0);
             *op++ = LZO_BYTE(m_len);
         }
+
         *op++ = LZO_BYTE((m_off & 63) << 2);
         *op++ = LZO_BYTE(m_off >> 6);
         c->m3_m++;
@@ -94,7 +97,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
 
 
 static lzo_bytep
-STORE_RUN ( lzo_bytep op, const lzo_bytep ii, lzo_uint t, lzo_bytep out )
+STORE_RUN(lzo_bytep op, const lzo_bytep ii, lzo_uint t, lzo_bytep out)
 {
     if (t < 4 && op > out)
         op[-2] = LZO_BYTE(op[-2] | t);
@@ -105,15 +108,20 @@ STORE_RUN ( lzo_bytep op, const lzo_bytep ii, lzo_uint t, lzo_bytep out )
         lzo_uint tt = t - 31;
 
         *op++ = 0;
+
         while (tt > 255)
         {
             tt -= 255;
             *op++ = 0;
         }
+
         assert(tt > 0);
         *op++ = LZO_BYTE(tt);
     }
-    do *op++ = *ii++; while (--t > 0);
+
+    do* op++ = *ii++;
+
+    while (--t > 0);
 
     return op;
 }
@@ -124,25 +132,25 @@ STORE_RUN ( lzo_bytep op, const lzo_bytep ii, lzo_uint t, lzo_bytep out )
 ************************************************************************/
 
 LZO_EXTERN(int)
-lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
+lzo1f_999_compress_callback(const lzo_bytep in , lzo_uint  in_len,
                             lzo_bytep out, lzo_uintp out_len,
                             lzo_voidp wrkmem,
                             lzo_callback_p cb,
-                                    lzo_uint max_chain );
+                            lzo_uint max_chain);
 
 LZO_PUBLIC(int)
-lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
+lzo1f_999_compress_callback(const lzo_bytep in , lzo_uint  in_len,
                             lzo_bytep out, lzo_uintp out_len,
                             lzo_voidp wrkmem,
                             lzo_callback_p cb,
-                                    lzo_uint max_chain )
+                            lzo_uint max_chain)
 {
     lzo_bytep op;
     const lzo_bytep ii;
     lzo_uint lit;
     lzo_uint m_len, m_off;
     LZO_COMPRESS_T cc;
-    LZO_COMPRESS_T * const c = &cc;
+    LZO_COMPRESS_T* const c = &cc;
     lzo_swd_p const swd = (lzo_swd_p) wrkmem;
     int r;
 
@@ -160,15 +168,19 @@ lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
     lit = 0;
     c->r1_lit = c->r1_m_len = 0;
 
-    r = init_match(c,swd,NULL,0,0);
+    r = init_match(c, swd, NULL, 0, 0);
+
     if (r != 0)
         return r;
+
     if (max_chain > 0)
         swd->max_chain = max_chain;
 
-    r = find_match(c,swd,0,0);
+    r = find_match(c, swd, 0, 0);
+
     if (r != 0)
         return r;
+
     while (c->look > 0)
     {
         int lazy_match_min_gain = -1;
@@ -178,8 +190,10 @@ lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
         m_off = c->m_off;
 
         assert(c->ip - c->look >= in);
+
         if (lit == 0)
             ii = c->ip - c->look;
+
         assert(ii + lit == c->ip - c->look);
         assert(swd->b_char == *(c->ip - c->look));
 
@@ -208,8 +222,9 @@ lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
         /* try a lazy match */
         if (m_len > 0 && lazy_match_min_gain >= 0 && c->look > m_len)
         {
-            r = find_match(c,swd,1,0);
-            assert(r == 0); LZO_UNUSED(r);
+            r = find_match(c, swd, 1, 0);
+            assert(r == 0);
+            LZO_UNUSED(r);
             assert(c->look > 0);
 
             if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET &&
@@ -250,8 +265,10 @@ lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
                 ahead = 1;
                 assert(ii + lit + 1 == c->ip - c->look);
             }
+
             assert(m_len > 0);
         }
+
         assert(ii + lit + ahead == c->ip - c->look);
 
 
@@ -259,15 +276,16 @@ lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
         {
             /* a literal */
             lit++;
-            r = find_match(c,swd,1,0);
-            assert(r == 0); LZO_UNUSED(r);
+            r = find_match(c, swd, 1, 0);
+            assert(r == 0);
+            LZO_UNUSED(r);
         }
         else
         {
             /* 1 - store run */
             if (lit > 0)
             {
-                op = STORE_RUN(op,ii,lit,out);
+                op = STORE_RUN(op, ii, lit, out);
                 c->r1_m_len = m_len;
                 c->r1_lit = lit;
                 lit = 0;
@@ -276,9 +294,10 @@ lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
                 c->r1_lit = c->r1_m_len = 0;
 
             /* 2 - code match */
-            op = code_match(c,op,m_len,m_off);
-            r = find_match(c,swd,m_len,1+ahead);
-            assert(r == 0); LZO_UNUSED(r);
+            op = code_match(c, op, m_len, m_off);
+            r = find_match(c, swd, m_len, 1 + ahead);
+            assert(r == 0);
+            LZO_UNUSED(r);
         }
 
         c->codesize = pd(op, out);
@@ -287,7 +306,7 @@ lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
 
     /* store final run */
     if (lit > 0)
-        op = STORE_RUN(op,ii,lit,out);
+        op = STORE_RUN(op, ii, lit, out);
 
 #if defined(LZO_EOF_CODE)
     *op++ = M3_MARKER | 1;
@@ -318,11 +337,11 @@ lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
 ************************************************************************/
 
 LZO_PUBLIC(int)
-lzo1f_999_compress  ( const lzo_bytep in , lzo_uint  in_len,
+lzo1f_999_compress(const lzo_bytep in , lzo_uint  in_len,
                    lzo_bytep out, lzo_uintp out_len,
-                            lzo_voidp wrkmem )
+                   lzo_voidp wrkmem)
 {
-    return lzo1f_999_compress_callback(in,in_len,out,out_len,wrkmem,
+    return lzo1f_999_compress_callback(in, in_len, out, out_len, wrkmem,
                                        (lzo_callback_p) 0, 0);
 }
 

extern/lzo/src/lzo1f_d.ch

@@ -34,9 +34,9 @@
 ************************************************************************/
 
 LZO_PUBLIC(int)
-DO_DECOMPRESS  ( const lzo_bytep in , lzo_uint  in_len,
+DO_DECOMPRESS(const lzo_bytep in , lzo_uint  in_len,
               lzo_bytep out, lzo_uintp out_len,
-                       lzo_voidp wrkmem )
+              lzo_voidp wrkmem)
 {
     lzo_bytep op;
     const lzo_bytep ip;
@@ -58,6 +58,7 @@ DO_DECOMPRESS  ( const lzo_bytep in , lzo_uint  in_len,
     while (TEST_IP_AND_TEST_OP)
     {
         t = *ip++;
+
         if (t > 31)
             goto match;
 
@@ -65,6 +66,7 @@ DO_DECOMPRESS  ( const lzo_bytep in , lzo_uint  in_len,
         if (t == 0)
         {
             NEED_IP(1);
+
             while (*ip == 0)
             {
                 t += 255;
@@ -72,22 +74,36 @@ DO_DECOMPRESS  ( const lzo_bytep in , lzo_uint  in_len,
                 TEST_IV(t);
                 NEED_IP(1);
             }
+
             t += 31 + *ip++;
         }
+
         /* copy literals */
-        assert(t > 0); NEED_OP(t); NEED_IP(t+1);
+        assert(t > 0);
+        NEED_OP(t);
+        NEED_IP(t + 1);
 #if (LZO_OPT_UNALIGNED32)
+
         if (t >= 4)
         {
-            do {
+            do
+            {
                 UA_COPY4(op, ip);
-                op += 4; ip += 4; t -= 4;
-            } while (t >= 4);
-            if (t > 0) do *op++ = *ip++; while (--t > 0);
+                op += 4;
+                ip += 4;
+                t -= 4;
+            }
+            while (t >= 4);
+
+            if (t > 0) do* op++ = *ip++;
+
+                while (--t > 0);
         }
         else
 #endif
-        do *op++ = *ip++; while (--t > 0);
+            do* op++ = *ip++;
+
+            while (--t > 0);
 
         t = *ip++;
 
@@ -99,27 +115,35 @@ DO_DECOMPRESS  ( const lzo_bytep in , lzo_uint  in_len,
                 m_pos = op - 1 - 0x800;
                 m_pos -= (t >> 2) & 7;
                 m_pos -= *ip++ << 3;
-                TEST_LB(m_pos); NEED_OP(3);
-                *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos++;
+                TEST_LB(m_pos);
+                NEED_OP(3);
+                *op++ = *m_pos++;
+                *op++ = *m_pos++;
+                *op++ = *m_pos++;
             }
             else
             {
 match:
+
                 if (t < M3_MARKER)
                 {
                     m_pos = op - 1;
                     m_pos -= (t >> 2) & 7;
                     m_pos -= *ip++ << 3;
                     t >>= 5;
-                    TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1);
+                    TEST_LB(m_pos);
+                    assert(t > 0);
+                    NEED_OP(t + 3 - 1);
                     goto copy_match;
                 }
                 else
                 {
                     t &= 31;
+
                     if (t == 0)
                     {
                         NEED_IP(1);
+
                         while (*ip == 0)
                         {
                             t += 255;
@@ -127,8 +151,10 @@ match:
                             TEST_OV(t);
                             NEED_IP(1);
                         }
+
                         t += 31 + *ip++;
                     }
+
                     NEED_IP(2);
                     m_pos = op;
 #if (LZO_OPT_UNALIGNED16) && (LZO_ABI_LITTLE_ENDIAN)
@@ -138,38 +164,64 @@ match:
                     m_pos -= *ip++ >> 2;
                     m_pos -= *ip++ << 6;
 #endif
+
                     if (m_pos == op)
                         goto eof_found;
                 }
 
                 /* copy match */
-                TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1);
+                TEST_LB(m_pos);
+                assert(t > 0);
+                NEED_OP(t + 3 - 1);
 #if (LZO_OPT_UNALIGNED32)
+
                 if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4)
                 {
                     UA_COPY4(op, m_pos);
-                    op += 4; m_pos += 4; t -= 4 - (3 - 1);
-                    do {
+                    op += 4;
+                    m_pos += 4;
+                    t -= 4 - (3 - 1);
+
+                    do
+                    {
                         UA_COPY4(op, m_pos);
-                        op += 4; m_pos += 4; t -= 4;
-                    } while (t >= 4);
-                    if (t > 0) do *op++ = *m_pos++; while (--t > 0);
+                        op += 4;
+                        m_pos += 4;
+                        t -= 4;
+                    }
+                    while (t >= 4);
+
+                    if (t > 0) do* op++ = *m_pos++;
+
+                        while (--t > 0);
                 }
                 else
 #endif
                 {
 copy_match:
-                *op++ = *m_pos++; *op++ = *m_pos++;
-                do *op++ = *m_pos++; while (--t > 0);
+                    *op++ = *m_pos++;
+                    *op++ = *m_pos++;
+
+                    do* op++ = *m_pos++;
+
+                    while (--t > 0);
                 }
             }
+
             t = ip[-2] & 3;
+
             if (t == 0)
                 break;
 
             /* copy literals */
-            assert(t > 0); NEED_OP(t); NEED_IP(t+1);
-            do *op++ = *ip++; while (--t > 0);
+            assert(t > 0);
+            NEED_OP(t);
+            NEED_IP(t + 1);
+
+            do* op++ = *ip++;
+
+            while (--t > 0);
+
             t = *ip++;
         }
     }

extern/lzo/src/lzo1f_d2.c

@@ -35,11 +35,11 @@
 
 #if defined(LZO_ARCH_I386) && defined(LZO_USE_ASM)
 LZO_EXTERN(int) lzo1f_decompress_asm_fast_safe
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem);
 LZO_PUBLIC(int) lzo1f_decompress_asm_fast_safe
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem)
 {

extern/lzo/src/lzo1x_9x.c

@@ -86,7 +86,7 @@
 
 /* this is a public functions, but there is no prototype in a header file */
 LZO_EXTERN(int)
-lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint  in_len,
+lzo1x_999_compress_internal(const lzo_bytep in , lzo_uint  in_len,
                             lzo_bytep out, lzo_uintp out_len,
                             lzo_voidp wrkmem,
                             const lzo_bytep dict, lzo_uint dict_len,
@@ -96,7 +96,7 @@ lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint  in_len,
                             lzo_uint max_lazy,
                             lzo_uint nice_length,
                             lzo_uint max_chain,
-                                    lzo_uint32_t flags );
+                            lzo_uint32_t flags);
 
 
 /***********************************************************************
@@ -104,7 +104,7 @@ lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint  in_len,
 ************************************************************************/
 
 static lzo_bytep
-code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
+code_match(LZO_COMPRESS_T* c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off)
 {
     lzo_uint x_len = m_len;
     lzo_uint x_off = m_off;
@@ -112,7 +112,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
     c->match_bytes += m_len;
 
 #if 0
-/*
+    /*
         static lzo_uint last_m_len = 0, last_m_off = 0;
         static lzo_uint prev_m_off[4];
         static unsigned prev_m_off_ptr = 0;
@@ -136,14 +136,16 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
         last_m_len = m_len;
         last_m_off = prev_m_off[prev_m_off_ptr] = m_off;
         prev_m_off_ptr = (prev_m_off_ptr + 1) & 3;
-*/
+    */
 #endif
 
     assert(op > c->out);
+
     if (m_len == 2)
     {
         assert(m_off <= M1_MAX_OFFSET);
-        assert(c->r1_lit > 0); assert(c->r1_lit < 4);
+        assert(c->r1_lit > 0);
+        assert(c->r1_lit < 4);
         m_off -= 1;
 #if defined(LZO1Z)
         *op++ = LZO_BYTE(M1_MARKER | (m_off >> 6));
@@ -154,6 +156,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
 #endif
         c->m1a_m++;
     }
+
 #if defined(LZO1Z)
     else if (m_len <= M2_MAX_LEN && (m_off <= M2_MAX_OFFSET || m_off == c->last_m_off))
 #else
@@ -172,6 +175,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
         *op++ = LZO_BYTE(m_off >> 2);
         assert(op[-2] >= M2_MARKER);
 #elif defined(LZO1Z)
+
         if (m_off == c->last_m_off)
             *op++ = LZO_BYTE(((m_len - 1) << 5) | (0x700 >> 6));
         else
@@ -180,6 +184,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
             *op++ = LZO_BYTE(((m_len - 1) << 5) | (m_off >> 6));
             *op++ = LZO_BYTE(m_off << 2);
         }
+
 #endif
         c->m2_m++;
     }
@@ -201,20 +206,24 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
     {
         assert(m_len >= 3);
         m_off -= 1;
+
         if (m_len <= M3_MAX_LEN)
             *op++ = LZO_BYTE(M3_MARKER | (m_len - 2));
         else
         {
             m_len -= M3_MAX_LEN;
             *op++ = M3_MARKER | 0;
+
             while (m_len > 255)
             {
                 m_len -= 255;
                 *op++ = 0;
             }
+
             assert(m_len > 0);
             *op++ = LZO_BYTE(m_len);
         }
+
 #if defined(LZO1Z)
         *op++ = LZO_BYTE(m_off >> 6);
         *op++ = LZO_BYTE(m_off << 2);
@@ -229,23 +238,28 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
         lzo_uint k;
 
         assert(m_len >= 3);
-        assert(m_off > 0x4000); assert(m_off <= 0xbfff);
+        assert(m_off > 0x4000);
+        assert(m_off <= 0xbfff);
         m_off -= 0x4000;
         k = (m_off & 0x4000) >> 11;
+
         if (m_len <= M4_MAX_LEN)
             *op++ = LZO_BYTE(M4_MARKER | k | (m_len - 2));
         else
         {
             m_len -= M4_MAX_LEN;
             *op++ = LZO_BYTE(M4_MARKER | k | 0);
+
             while (m_len > 255)
             {
                 m_len -= 255;
                 *op++ = 0;
             }
+
             assert(m_len > 0);
             *op++ = LZO_BYTE(m_len);
         }
+
 #if defined(LZO1Z)
         *op++ = LZO_BYTE(m_off >> 6);
         *op++ = LZO_BYTE(m_off << 2);
@@ -263,7 +277,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
 
 
 static lzo_bytep
-STORE_RUN ( LZO_COMPRESS_T *c, lzo_bytep op, const lzo_bytep ii, lzo_uint t )
+STORE_RUN(LZO_COMPRESS_T* c, lzo_bytep op, const lzo_bytep ii, lzo_uint t)
 {
     c->lit_bytes += t;
 
@@ -290,29 +304,34 @@ STORE_RUN ( LZO_COMPRESS_T *c, lzo_bytep op, const lzo_bytep ii, lzo_uint t )
         lzo_uint tt = t - 18;
 
         *op++ = 0;
+
         while (tt > 255)
         {
             tt -= 255;
             *op++ = 0;
         }
+
         assert(tt > 0);
         *op++ = LZO_BYTE(tt);
         c->lit3_r++;
     }
-    do *op++ = *ii++; while (--t > 0);
+
+    do* op++ = *ii++;
+
+    while (--t > 0);
 
     return op;
 }
 
 
 static lzo_bytep
-code_run ( LZO_COMPRESS_T *c, lzo_bytep op, const lzo_bytep ii,
-           lzo_uint lit, lzo_uint m_len )
+code_run(LZO_COMPRESS_T* c, lzo_bytep op, const lzo_bytep ii,
+         lzo_uint lit, lzo_uint m_len)
 {
     if (lit > 0)
     {
         assert(m_len >= 2);
-        op = STORE_RUN(c,op,ii,lit);
+        op = STORE_RUN(c, op, ii, lit);
         c->r1_m_len = m_len;
         c->r1_lit = lit;
     }
@@ -332,42 +351,54 @@ code_run ( LZO_COMPRESS_T *c, lzo_bytep op, const lzo_bytep ii,
 ************************************************************************/
 
 static lzo_uint
-len_of_coded_match ( lzo_uint m_len, lzo_uint m_off, lzo_uint lit )
+len_of_coded_match(lzo_uint m_len, lzo_uint m_off, lzo_uint lit)
 {
     lzo_uint n = 4;
 
     if (m_len < 2)
         return 0;
+
     if (m_len == 2)
         return (m_off <= M1_MAX_OFFSET && lit > 0 && lit < 4) ? 2 : 0;
+
     if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
         return 2;
+
     if (m_len == M2_MIN_LEN && m_off <= MX_MAX_OFFSET && lit >= 4)
         return 2;
+
     if (m_off <= M3_MAX_OFFSET)
     {
         if (m_len <= M3_MAX_LEN)
             return 3;
+
         m_len -= M3_MAX_LEN;
+
         while (m_len > 255)
         {
             m_len -= 255;
             n++;
         }
+
         return n;
     }
+
     if (m_off <= M4_MAX_OFFSET)
     {
         if (m_len <= M4_MAX_LEN)
             return 3;
+
         m_len -= M4_MAX_LEN;
+
         while (m_len > 255)
         {
             m_len -= 255;
             n++;
         }
+
         return n;
     }
+
     return 0;
 }
 
@@ -377,12 +408,14 @@ min_gain(lzo_uint ahead, lzo_uint lit1, lzo_uint lit2, lzo_uint l1, lzo_uint l2,
 {
     lzo_uint lazy_match_min_gain;
 
-    assert (ahead >= 1);
+    assert(ahead >= 1);
     lazy_match_min_gain = ahead;
 
 #if 0
+
     if (l3)
         lit2 -= ahead;
+
 #endif
 
     if (lit1 <= 3)
@@ -391,6 +424,7 @@ min_gain(lzo_uint ahead, lzo_uint lit1, lzo_uint lit2, lzo_uint l1, lzo_uint l2,
         lazy_match_min_gain += (lit2 <= 18) ? 0 : 1;
 
     lazy_match_min_gain += (l2 - l1) * 2;
+
     if (l3)
         lazy_match_min_gain -= (ahead - l3) * 2;
 
@@ -398,9 +432,11 @@ min_gain(lzo_uint ahead, lzo_uint lit1, lzo_uint lit2, lzo_uint l1, lzo_uint l2,
         lazy_match_min_gain = 0;
 
 #if 0
+
     if (l1 == 2)
         if (lazy_match_min_gain == 0)
             lazy_match_min_gain = 1;
+
 #endif
 
     return lazy_match_min_gain;
@@ -413,13 +449,14 @@ min_gain(lzo_uint ahead, lzo_uint lit1, lzo_uint lit2, lzo_uint l1, lzo_uint l2,
 
 #if !defined(NDEBUG)
 static
-void assert_match( const lzo_swd_p swd, lzo_uint m_len, lzo_uint m_off )
+void assert_match(const lzo_swd_p swd, lzo_uint m_len, lzo_uint m_off)
 {
-    const LZO_COMPRESS_T *c = swd->c;
+    const LZO_COMPRESS_T* c = swd->c;
     lzo_uint d_off;
 
     assert(m_len >= 2);
-    if (m_off <= (lzo_uint) (c->bp - c->in))
+
+    if (m_off <= (lzo_uint)(c->bp - c->in))
     {
         assert(c->bp - m_off + m_len < c->ip);
         assert(lzo_memcmp(c->bp, c->bp - m_off, m_len) == 0);
@@ -427,8 +464,9 @@ void assert_match( const lzo_swd_p swd, lzo_uint m_len, lzo_uint m_off )
     else
     {
         assert(swd->dict != NULL);
-        d_off = m_off - (lzo_uint) (c->bp - c->in);
+        d_off = m_off - (lzo_uint)(c->bp - c->in);
         assert(d_off <= swd->dict_len);
+
         if (m_len > d_off)
         {
             assert(lzo_memcmp(c->bp, swd->dict_end - d_off, d_off) == 0);
@@ -449,25 +487,30 @@ void assert_match( const lzo_swd_p swd, lzo_uint m_len, lzo_uint m_off )
 #if defined(SWD_BEST_OFF)
 
 static void
-better_match ( const lzo_swd_p swd, lzo_uint *m_len, lzo_uint *m_off )
+better_match(const lzo_swd_p swd, lzo_uint* m_len, lzo_uint* m_off)
 {
 #if defined(LZO1Z)
-    const LZO_COMPRESS_T *c = swd->c;
+    const LZO_COMPRESS_T* c = swd->c;
 #endif
 
     if (*m_len <= M2_MIN_LEN)
         return;
+
 #if defined(LZO1Z)
+
     if (*m_off == c->last_m_off && *m_len <= M2_MAX_LEN)
         return;
+
 #if 1
+
     if (*m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 &&
-        c->last_m_off && swd->best_off[*m_len-1] == c->last_m_off)
+            c->last_m_off && swd->best_off[*m_len - 1] == c->last_m_off)
     {
         *m_len = *m_len - 1;
         *m_off = swd->best_off[*m_len];
         return;
     }
+
 #endif
 #endif
 
@@ -475,38 +518,44 @@ better_match ( const lzo_swd_p swd, lzo_uint *m_len, lzo_uint *m_off )
         return;
 
 #if 1
+
     /* M3/M4 -> M2 */
     if (*m_off > M2_MAX_OFFSET &&
             *m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 &&
-        swd->best_off[*m_len-1] && swd->best_off[*m_len-1] <= M2_MAX_OFFSET)
+            swd->best_off[*m_len - 1] && swd->best_off[*m_len - 1] <= M2_MAX_OFFSET)
     {
         *m_len = *m_len - 1;
         *m_off = swd->best_off[*m_len];
         return;
     }
+
 #endif
 
 #if 1
+
     /* M4 -> M2 */
     if (*m_off > M3_MAX_OFFSET &&
             *m_len >= M4_MAX_LEN + 1 && *m_len <= M2_MAX_LEN + 2 &&
-        swd->best_off[*m_len-2] && swd->best_off[*m_len-2] <= M2_MAX_OFFSET)
+            swd->best_off[*m_len - 2] && swd->best_off[*m_len - 2] <= M2_MAX_OFFSET)
     {
         *m_len = *m_len - 2;
         *m_off = swd->best_off[*m_len];
         return;
     }
+
 #endif
 
 #if 1
+
     /* M4 -> M3 */
     if (*m_off > M3_MAX_OFFSET &&
             *m_len >= M4_MAX_LEN + 1 && *m_len <= M3_MAX_LEN + 1 &&
-        swd->best_off[*m_len-1] && swd->best_off[*m_len-1] <= M3_MAX_OFFSET)
+            swd->best_off[*m_len - 1] && swd->best_off[*m_len - 1] <= M3_MAX_OFFSET)
     {
         *m_len = *m_len - 1;
         *m_off = swd->best_off[*m_len];
     }
+
 #endif
 }
 
@@ -518,7 +567,7 @@ better_match ( const lzo_swd_p swd, lzo_uint *m_len, lzo_uint *m_off )
 ************************************************************************/
 
 LZO_PUBLIC(int)
-lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint  in_len,
+lzo1x_999_compress_internal(const lzo_bytep in , lzo_uint  in_len,
                             lzo_bytep out, lzo_uintp out_len,
                             lzo_voidp wrkmem,
                             const lzo_bytep dict, lzo_uint dict_len,
@@ -528,14 +577,14 @@ lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint  in_len,
                             lzo_uint max_lazy,
                             lzo_uint nice_length,
                             lzo_uint max_chain,
-                                    lzo_uint32_t flags )
+                            lzo_uint32_t flags)
 {
     lzo_bytep op;
     const lzo_bytep ii;
     lzo_uint lit;
     lzo_uint m_len, m_off;
     LZO_COMPRESS_T cc;
-    LZO_COMPRESS_T * const c = &cc;
+    LZO_COMPRESS_T* const c = &cc;
     lzo_swd_p const swd = (lzo_swd_p) wrkmem;
     lzo_uint try_lazy;
     int r;
@@ -551,20 +600,25 @@ lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint  in_len,
 #  error
 #endif
 
-/* setup parameter defaults */
+    /* setup parameter defaults */
     /* number of lazy match tries */
     try_lazy = (lzo_uint) try_lazy_parm;
+
     if (try_lazy_parm < 0)
         try_lazy = 1;
+
     /* reduce lazy match search if we already have a match with this length */
     if (good_length == 0)
         good_length = 32;
+
     /* do not try a lazy match if we already have a match with this length */
     if (max_lazy == 0)
         max_lazy = 32;
+
     /* stop searching for longer matches than this one */
     if (nice_length == 0)
         nice_length = 0;
+
     /* don't search more positions than this */
     if (max_chain == 0)
         max_chain = SWD_MAX_CHAIN;
@@ -582,17 +636,22 @@ lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint  in_len,
     lit = 0;
     c->r1_lit = c->r1_m_len = 0;
 
-    r = init_match(c,swd,dict,dict_len,flags);
+    r = init_match(c, swd, dict, dict_len, flags);
+
     if (r != 0)
         return r;
+
     if (max_chain > 0)
         swd->max_chain = max_chain;
+
     if (nice_length > 0)
         swd->nice_length = nice_length;
 
-    r = find_match(c,swd,0,0);
+    r = find_match(c, swd, 0, 0);
+
     if (r != 0)
         return r;
+
     while (c->look > 0)
     {
         lzo_uint ahead;
@@ -606,12 +665,14 @@ lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint  in_len,
 
         assert(c->bp == c->ip - c->look);
         assert(c->bp >= in);
+
         if (lit == 0)
             ii = c->bp;
+
         assert(ii + lit == c->bp);
         assert(swd->b_char == *(c->bp));
 
-        if ( m_len < 2 ||
+        if (m_len < 2 ||
                 (m_len == 2 && (m_off > M1_MAX_OFFSET || lit == 0 || lit >= 4)) ||
 #if 1
                 /* Do not accept this match for compressed-data compatibility
@@ -637,21 +698,25 @@ lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint  in_len,
             /* a literal */
             lit++;
             swd->max_chain = max_chain;
-            r = find_match(c,swd,1,0);
-            assert(r == 0); LZO_UNUSED(r);
+            r = find_match(c, swd, 1, 0);
+            assert(r == 0);
+            LZO_UNUSED(r);
             continue;
         }
 
         /* a match */
 #if defined(SWD_BEST_OFF)
+
         if (swd->use_best_off)
-            better_match(swd,&m_len,&m_off);
+            better_match(swd, &m_len, &m_off);
+
 #endif
-        assert_match(swd,m_len,m_off);
+        assert_match(swd, m_len, m_off);
 
 
         /* shall we try a lazy match ? */
         ahead = 0;
+
         if (try_lazy == 0 || m_len >= max_lazy)
         {
             /* no */
@@ -661,7 +726,7 @@ lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint  in_len,
         else
         {
             /* yes, try a lazy match */
-            l1 = len_of_coded_match(m_len,m_off,lit);
+            l1 = len_of_coded_match(m_len, m_off, lit);
             assert(l1 > 0);
 #if 1
             max_ahead = LZO_MIN(try_lazy, l1 - 1);
@@ -679,63 +744,79 @@ lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint  in_len,
                 swd->max_chain = max_chain >> 2;
             else
                 swd->max_chain = max_chain;
-            r = find_match(c,swd,1,0);
+
+            r = find_match(c, swd, 1, 0);
             ahead++;
 
-            assert(r == 0); LZO_UNUSED(r);
+            assert(r == 0);
+            LZO_UNUSED(r);
             assert(c->look > 0);
             assert(ii + lit + ahead == c->bp);
 
 #if defined(LZO1Z)
+
             if (m_off == c->last_m_off && c->m_off != c->last_m_off)
                 if (m_len >= M2_MIN_LEN && m_len <= M2_MAX_LEN)
                     c->m_len = 0;
+
 #endif
+
             if (c->m_len < m_len)
                 continue;
+
 #if 1
+
             if (c->m_len == m_len && c->m_off >= m_off)
                 continue;
+
 #endif
 #if defined(SWD_BEST_OFF)
+
             if (swd->use_best_off)
-                better_match(swd,&c->m_len,&c->m_off);
+                better_match(swd, &c->m_len, &c->m_off);
+
 #endif
-            l2 = len_of_coded_match(c->m_len,c->m_off,lit+ahead);
+            l2 = len_of_coded_match(c->m_len, c->m_off, lit + ahead);
+
             if (l2 == 0)
                 continue;
+
 #if 0
+
             if (c->m_len == m_len && l2 >= l1)
                 continue;
+
 #endif
 
 
 #if 1
             /* compressed-data compatibility [see above] */
-            l3 = (op == out) ? 0 : len_of_coded_match(ahead,m_off,lit);
+            l3 = (op == out) ? 0 : len_of_coded_match(ahead, m_off, lit);
 #else
-            l3 = len_of_coded_match(ahead,m_off,lit);
+            l3 = len_of_coded_match(ahead, m_off, lit);
 #endif
 
-            lazy_match_min_gain = min_gain(ahead,lit,lit+ahead,l1,l2,l3);
+            lazy_match_min_gain = min_gain(ahead, lit, lit + ahead, l1, l2, l3);
+
             if (c->m_len >= m_len + lazy_match_min_gain)
             {
                 c->lazy++;
-                assert_match(swd,c->m_len,c->m_off);
+                assert_match(swd, c->m_len, c->m_off);
 
                 if (l3)
                 {
                     /* code previous run */
-                    op = code_run(c,op,ii,lit,ahead);
+                    op = code_run(c, op, ii, lit, ahead);
                     lit = 0;
                     /* code shortened match */
-                    op = code_match(c,op,ahead,m_off);
+                    op = code_match(c, op, ahead, m_off);
                 }
                 else
                 {
                     lit += ahead;
                     assert(ii + lit == c->bp);
                 }
+
                 goto lazy_match_done;
             }
         }
@@ -744,22 +825,24 @@ lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint  in_len,
         assert(ii + lit + ahead == c->bp);
 
         /* 1 - code run */
-        op = code_run(c,op,ii,lit,m_len);
+        op = code_run(c, op, ii, lit, m_len);
         lit = 0;
 
         /* 2 - code match */
-        op = code_match(c,op,m_len,m_off);
+        op = code_match(c, op, m_len, m_off);
         swd->max_chain = max_chain;
-        r = find_match(c,swd,m_len,1+ahead);
-        assert(r == 0); LZO_UNUSED(r);
+        r = find_match(c, swd, m_len, 1 + ahead);
+        assert(r == 0);
+        LZO_UNUSED(r);
 
-lazy_match_done: ;
+lazy_match_done:
+        ;
     }
 
 
     /* store final run */
     if (lit > 0)
-        op = STORE_RUN(c,op,ii,lit);
+        op = STORE_RUN(c, op, ii, lit);
 
 #if defined(LZO_EOF_CODE)
     *op++ = M4_MARKER | 1;
@@ -792,12 +875,12 @@ lazy_match_done: ;
 ************************************************************************/
 
 LZO_PUBLIC(int)
-lzo1x_999_compress_level    ( const lzo_bytep in , lzo_uint  in_len,
+lzo1x_999_compress_level(const lzo_bytep in , lzo_uint  in_len,
                          lzo_bytep out, lzo_uintp out_len,
                          lzo_voidp wrkmem,
                          const lzo_bytep dict, lzo_uint dict_len,
                          lzo_callback_p cb,
-                                    int compression_level )
+                         int compression_level)
 {
     static const struct
     {
@@ -807,7 +890,8 @@ lzo1x_999_compress_level    ( const lzo_bytep in , lzo_uint  in_len,
         lzo_uint nice_length;
         lzo_uint max_chain;
         lzo_uint32_t flags;
-    } c[9] = {
+    } c[9] =
+    {
         /* faster compression */
         {   0,     0,     0,     8,    4,   0 },
         {   0,     0,     0,    16,    8,   0 },
@@ -845,19 +929,19 @@ lzo1x_999_compress_level    ( const lzo_bytep in , lzo_uint  in_len,
 ************************************************************************/
 
 LZO_PUBLIC(int)
-lzo1x_999_compress_dict     ( const lzo_bytep in , lzo_uint  in_len,
+lzo1x_999_compress_dict(const lzo_bytep in , lzo_uint  in_len,
                         lzo_bytep out, lzo_uintp out_len,
                         lzo_voidp wrkmem,
-                              const lzo_bytep dict, lzo_uint dict_len )
+                        const lzo_bytep dict, lzo_uint dict_len)
 {
     return lzo1x_999_compress_level(in, in_len, out, out_len, wrkmem,
                                     dict, dict_len, 0, 8);
 }
 
 LZO_PUBLIC(int)
-lzo1x_999_compress  ( const lzo_bytep in , lzo_uint  in_len,
+lzo1x_999_compress(const lzo_bytep in , lzo_uint  in_len,
                    lzo_bytep out, lzo_uintp out_len,
-                            lzo_voidp wrkmem )
+                   lzo_voidp wrkmem)
 {
     return lzo1x_999_compress_level(in, in_len, out, out_len, wrkmem,
                                     NULL, 0, (lzo_callback_p) 0, 8);

extern/lzo/src/lzo1x_c.ch

@@ -28,7 +28,7 @@
 
 
 #if 1 && defined(DO_COMPRESS) && !defined(do_compress)
-   /* choose a unique name to better help PGO optimizations */
+/* choose a unique name to better help PGO optimizations */
 #  define do_compress       LZO_PP_ECONCAT2(DO_COMPRESS,_core)
 #endif
 
@@ -38,7 +38,7 @@
 ************************************************************************/
 
 static __lzo_noinline lzo_uint
-do_compress ( const lzo_bytep in , lzo_uint  in_len,
+do_compress(const lzo_bytep in , lzo_uint  in_len,
             lzo_bytep out, lzo_uintp out_len,
             lzo_uint  ti,  lzo_voidp wrkmem)
 {
@@ -54,6 +54,7 @@ do_compress ( const lzo_bytep in , lzo_uint  in_len,
     ii = ip;
 
     ip += ti < 4 ? 4 - ti : 0;
+
     for (;;)
     {
         const lzo_bytep m_pos;
@@ -62,26 +63,36 @@ do_compress ( const lzo_bytep in , lzo_uint  in_len,
         lzo_uint m_len;
         lzo_uint dindex;
 next:
+
         if __lzo_unlikely(ip >= ip_end)
             break;
-        DINDEX1(dindex,ip);
-        GINDEX(m_pos,m_off,dict,dindex,in);
-        if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M4_MAX_OFFSET))
+
+        DINDEX1(dindex, ip);
+        GINDEX(m_pos, m_off, dict, dindex, in);
+
+        if (LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, M4_MAX_OFFSET))
             goto literal;
+
 #if 1
+
         if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
             goto try_match;
-        DINDEX2(dindex,ip);
+
+        DINDEX2(dindex, ip);
 #endif
-        GINDEX(m_pos,m_off,dict,dindex,in);
-        if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M4_MAX_OFFSET))
+        GINDEX(m_pos, m_off, dict, dindex, in);
+
+        if (LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, M4_MAX_OFFSET))
             goto literal;
+
         if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
             goto try_match;
+
         goto literal;
 
 try_match:
 #if (LZO_OPT_UNALIGNED32)
+
         if (UA_GET_NE32(m_pos) != UA_GET_NE32(ip))
 #else
         if (m_pos[0] != ip[0] || m_pos[1] != ip[1] || m_pos[2] != ip[2] || m_pos[3] != ip[3])
@@ -89,12 +100,13 @@ try_match:
         {
             /* a literal */
 literal:
-            UPDATE_I(dict,0,dindex,ip,in);
+            UPDATE_I(dict, 0, dindex, ip, in);
             ip += 1 + ((ip - ii) >> 5);
             continue;
         }
-/*match:*/
-        UPDATE_I(dict,0,dindex,ip,in);
+
+        /*match:*/
+        UPDATE_I(dict, 0, dindex, ip, in);
 #else
         lzo_uint m_off;
         lzo_uint m_len;
@@ -104,12 +116,15 @@ literal:
 literal:
             ip += 1 + ((ip - ii) >> 5);
 next:
+
             if __lzo_unlikely(ip >= ip_end)
                 break;
+
             dv = UA_GET_LE32(ip);
-        dindex = DINDEX(dv,ip);
-        GINDEX(m_off,m_pos,in+dict,dindex,in);
-        UPDATE_I(dict,0,dindex,ip,in);
+            dindex = DINDEX(dv, ip);
+            GINDEX(m_off, m_pos, in + dict, dindex, in);
+            UPDATE_I(dict, 0, dindex, ip, in);
+
             if __lzo_unlikely(dv != UA_GET_LE32(m_pos))
                 goto literal;
         }
@@ -117,9 +132,11 @@ next:
 
         /* a match */
 
-        ii -= ti; ti = 0;
+        ii -= ti;
+        ti = 0;
         {
-        lzo_uint t = pd(ip,ii);
+            lzo_uint t = pd(ip, ii);
+
             if (t != 0)
             {
                 if (t <= 3)
@@ -129,17 +146,19 @@ next:
                     UA_COPY4(op, ii);
                     op += t;
 #else
-                { do *op++ = *ii++; while (--t > 0); }
+                    { do* op++ = *ii++; while (--t > 0); }
 #endif
                 }
+
 #if (LZO_OPT_UNALIGNED32) || (LZO_OPT_UNALIGNED64)
                 else if (t <= 16)
                 {
                     *op++ = LZO_BYTE(t - 3);
                     UA_COPY8(op, ii);
-                UA_COPY8(op+8, ii+8);
+                    UA_COPY8(op + 8, ii + 8);
                     op += t;
                 }
+
 #endif
                 else
                 {
@@ -149,23 +168,33 @@ next:
                     {
                         lzo_uint tt = t - 18;
                         *op++ = 0;
+
                         while __lzo_unlikely(tt > 255)
                         {
                             tt -= 255;
                             UA_SET1(op, 0);
                             op++;
                         }
+
                         assert(tt > 0);
                         *op++ = LZO_BYTE(tt);
                     }
+
 #if (LZO_OPT_UNALIGNED32) || (LZO_OPT_UNALIGNED64)
-                do {
+
+                    do
+                    {
                         UA_COPY8(op, ii);
-                    UA_COPY8(op+8, ii+8);
-                    op += 16; ii += 16; t -= 16;
-                } while (t >= 16); if (t > 0)
+                        UA_COPY8(op + 8, ii + 8);
+                        op += 16;
+                        ii += 16;
+                        t -= 16;
+                    }
+                    while (t >= 16);
+
+                    if (t > 0)
 #endif
-                { do *op++ = *ii++; while (--t > 0); }
+                    { do* op++ = *ii++; while (--t > 0); }
                 }
             }
         }
@@ -174,102 +203,161 @@ next:
 #if (LZO_OPT_UNALIGNED64)
             lzo_uint64_t v;
             v = UA_GET_NE64(ip + m_len) ^ UA_GET_NE64(m_pos + m_len);
-        if __lzo_unlikely(v == 0) {
-            do {
+
+            if __lzo_unlikely(v == 0)
+            {
+                do
+                {
                     m_len += 8;
                     v = UA_GET_NE64(ip + m_len) ^ UA_GET_NE64(m_pos + m_len);
+
                     if __lzo_unlikely(ip + m_len >= ip_end)
                         goto m_len_done;
-            } while (v == 0);
                 }
+                while (v == 0);
+            }
+
 #if (LZO_ABI_BIG_ENDIAN) && defined(lzo_bitops_ctlz64)
             m_len += lzo_bitops_ctlz64(v) / CHAR_BIT;
 #elif (LZO_ABI_BIG_ENDIAN)
-        if ((v >> (64 - CHAR_BIT)) == 0) do {
+
+            if ((v >> (64 - CHAR_BIT)) == 0) do
+                {
                     v <<= CHAR_BIT;
                     m_len += 1;
-        } while ((v >> (64 - CHAR_BIT)) == 0);
+                }
+                while ((v >> (64 - CHAR_BIT)) == 0);
+
 #elif (LZO_ABI_LITTLE_ENDIAN) && defined(lzo_bitops_cttz64)
             m_len += lzo_bitops_cttz64(v) / CHAR_BIT;
 #elif (LZO_ABI_LITTLE_ENDIAN)
-        if ((v & UCHAR_MAX) == 0) do {
+
+            if ((v & UCHAR_MAX) == 0) do
+                {
                     v >>= CHAR_BIT;
                     m_len += 1;
-        } while ((v & UCHAR_MAX) == 0);
+                }
+                while ((v & UCHAR_MAX) == 0);
+
 #else
-        if (ip[m_len] == m_pos[m_len]) do {
+
+            if (ip[m_len] == m_pos[m_len]) do
+                {
                     m_len += 1;
-        } while (ip[m_len] == m_pos[m_len]);
+                }
+                while (ip[m_len] == m_pos[m_len]);
+
 #endif
 #elif (LZO_OPT_UNALIGNED32)
             lzo_uint32_t v;
             v = UA_GET_NE32(ip + m_len) ^ UA_GET_NE32(m_pos + m_len);
-        if __lzo_unlikely(v == 0) {
-            do {
+
+            if __lzo_unlikely(v == 0)
+            {
+                do
+                {
                     m_len += 4;
                     v = UA_GET_NE32(ip + m_len) ^ UA_GET_NE32(m_pos + m_len);
+
                     if (v != 0)
                         break;
+
                     m_len += 4;
                     v = UA_GET_NE32(ip + m_len) ^ UA_GET_NE32(m_pos + m_len);
+
                     if __lzo_unlikely(ip + m_len >= ip_end)
                         goto m_len_done;
-            } while (v == 0);
                 }
+                while (v == 0);
+            }
+
 #if (LZO_ABI_BIG_ENDIAN) && defined(lzo_bitops_ctlz32)
             m_len += lzo_bitops_ctlz32(v) / CHAR_BIT;
 #elif (LZO_ABI_BIG_ENDIAN)
-        if ((v >> (32 - CHAR_BIT)) == 0) do {
+
+            if ((v >> (32 - CHAR_BIT)) == 0) do
+                {
                     v <<= CHAR_BIT;
                     m_len += 1;
-        } while ((v >> (32 - CHAR_BIT)) == 0);
+                }
+                while ((v >> (32 - CHAR_BIT)) == 0);
+
 #elif (LZO_ABI_LITTLE_ENDIAN) && defined(lzo_bitops_cttz32)
             m_len += lzo_bitops_cttz32(v) / CHAR_BIT;
 #elif (LZO_ABI_LITTLE_ENDIAN)
-        if ((v & UCHAR_MAX) == 0) do {
+
+            if ((v & UCHAR_MAX) == 0) do
+                {
                     v >>= CHAR_BIT;
                     m_len += 1;
-        } while ((v & UCHAR_MAX) == 0);
+                }
+                while ((v & UCHAR_MAX) == 0);
+
 #else
-        if (ip[m_len] == m_pos[m_len]) do {
+
+            if (ip[m_len] == m_pos[m_len]) do
+                {
                     m_len += 1;
-        } while (ip[m_len] == m_pos[m_len]);
+                }
+                while (ip[m_len] == m_pos[m_len]);
+
 #endif
 #else
-        if __lzo_unlikely(ip[m_len] == m_pos[m_len]) {
-            do {
+
+            if __lzo_unlikely(ip[m_len] == m_pos[m_len])
+            {
+                do
+                {
                     m_len += 1;
+
                     if (ip[m_len] != m_pos[m_len])
                         break;
+
                     m_len += 1;
+
                     if (ip[m_len] != m_pos[m_len])
                         break;
+
                     m_len += 1;
+
                     if (ip[m_len] != m_pos[m_len])
                         break;
+
                     m_len += 1;
+
                     if (ip[m_len] != m_pos[m_len])
                         break;
+
                     m_len += 1;
+
                     if (ip[m_len] != m_pos[m_len])
                         break;
+
                     m_len += 1;
+
                     if (ip[m_len] != m_pos[m_len])
                         break;
+
                     m_len += 1;
+
                     if (ip[m_len] != m_pos[m_len])
                         break;
+
                     m_len += 1;
+
                     if __lzo_unlikely(ip + m_len >= ip_end)
                         goto m_len_done;
-            } while (ip[m_len] == m_pos[m_len]);
                 }
+                while (ip[m_len] == m_pos[m_len]);
+            }
+
 #endif
         }
 m_len_done:
-        m_off = pd(ip,m_pos);
+        m_off = pd(ip, m_pos);
         ip += m_len;
         ii = ip;
+
         if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
         {
             m_off -= 1;
@@ -284,48 +372,57 @@ m_len_done:
         else if (m_off <= M3_MAX_OFFSET)
         {
             m_off -= 1;
+
             if (m_len <= M3_MAX_LEN)
                 *op++ = LZO_BYTE(M3_MARKER | (m_len - 2));
             else
             {
                 m_len -= M3_MAX_LEN;
                 *op++ = M3_MARKER | 0;
+
                 while __lzo_unlikely(m_len > 255)
                 {
                     m_len -= 255;
                     UA_SET1(op, 0);
                     op++;
                 }
+
                 *op++ = LZO_BYTE(m_len);
             }
+
             *op++ = LZO_BYTE(m_off << 2);
             *op++ = LZO_BYTE(m_off >> 6);
         }
         else
         {
             m_off -= 0x4000;
+
             if (m_len <= M4_MAX_LEN)
                 *op++ = LZO_BYTE(M4_MARKER | ((m_off >> 11) & 8) | (m_len - 2));
             else
             {
                 m_len -= M4_MAX_LEN;
                 *op++ = LZO_BYTE(M4_MARKER | ((m_off >> 11) & 8));
+
                 while __lzo_unlikely(m_len > 255)
                 {
                     m_len -= 255;
                     UA_SET1(op, 0);
                     op++;
                 }
+
                 *op++ = LZO_BYTE(m_len);
             }
+
             *op++ = LZO_BYTE(m_off << 2);
             *op++ = LZO_BYTE(m_off >> 6);
         }
+
         goto next;
     }
 
     *out_len = pd(op, out);
-    return pd(in_end,ii-ti);
+    return pd(in_end, ii - ti);
 }
 
 
@@ -334,9 +431,9 @@ m_len_done:
 ************************************************************************/
 
 LZO_PUBLIC(int)
-DO_COMPRESS      ( const lzo_bytep in , lzo_uint  in_len,
+DO_COMPRESS(const lzo_bytep in , lzo_uint  in_len,
             lzo_bytep out, lzo_uintp out_len,
-                         lzo_voidp wrkmem )
+            lzo_voidp wrkmem)
 {
     const lzo_bytep ip = in;
     lzo_bytep op = out;
@@ -351,16 +448,19 @@ DO_COMPRESS      ( const lzo_bytep in , lzo_uint  in_len,
         ll = LZO_MIN(ll, 49152);
 #endif
         ll_end = (lzo_uintptr_t)ip + ll;
+
         if ((ll_end + ((t + ll) >> 5)) <= ll_end || (const lzo_bytep)(ll_end + ((t + ll) >> 5)) <= ip + ll)
             break;
+
 #if (LZO_DETERMINISTIC)
         lzo_memset(wrkmem, 0, ((lzo_uint)1 << D_BITS) * sizeof(lzo_dict_t));
 #endif
-        t = do_compress(ip,ll,op,out_len,t,wrkmem);
+        t = do_compress(ip, ll, op, out_len, t, wrkmem);
         ip += ll;
         op += *out_len;
         l  -= ll;
     }
+
     t += l;
 
     if (t > 0)
@@ -378,15 +478,18 @@ DO_COMPRESS      ( const lzo_bytep in , lzo_uint  in_len,
             lzo_uint tt = t - 18;
 
             *op++ = 0;
+
             while (tt > 255)
             {
                 tt -= 255;
                 UA_SET1(op, 0);
                 op++;
             }
+
             assert(tt > 0);
             *op++ = LZO_BYTE(tt);
         }
+
         UA_COPYN(op, ii, t);
         op += t;
     }

extern/lzo/src/lzo1x_d.ch

@@ -35,9 +35,9 @@
 
 #if defined(DO_DECOMPRESS)
 LZO_PUBLIC(int)
-DO_DECOMPRESS  ( const lzo_bytep in , lzo_uint  in_len,
+DO_DECOMPRESS(const lzo_bytep in , lzo_uint  in_len,
               lzo_bytep out, lzo_uintp out_len,
-                       lzo_voidp wrkmem )
+              lzo_voidp wrkmem)
 #endif
 {
     lzo_bytep op;
@@ -61,6 +61,7 @@ DO_DECOMPRESS  ( const lzo_bytep in , lzo_uint  in_len,
     LZO_UNUSED(wrkmem);
 
 #if defined(COPY_DICT)
+
     if (dict)
     {
         if (dict_len > M4_MAX_OFFSET)
@@ -68,6 +69,7 @@ DO_DECOMPRESS  ( const lzo_bytep in , lzo_uint  in_len,
             dict += dict_len - M4_MAX_OFFSET;
             dict_len = M4_MAX_OFFSET;
         }
+
         dict_end = dict + dict_len;
     }
     else
@@ -75,6 +77,7 @@ DO_DECOMPRESS  ( const lzo_bytep in , lzo_uint  in_len,
         dict_len = 0;
         dict_end = NULL;
     }
+
 #endif /* COPY_DICT */
 
     *out_len = 0;
@@ -83,13 +86,22 @@ DO_DECOMPRESS  ( const lzo_bytep in , lzo_uint  in_len,
     ip = in;
 
     NEED_IP(1);
+
     if (*ip > 17)
     {
         t = *ip++ - 17;
+
         if (t < 4)
             goto match_next;
-        assert(t > 0); NEED_OP(t); NEED_IP(t+3);
-        do *op++ = *ip++; while (--t > 0);
+
+        assert(t > 0);
+        NEED_OP(t);
+        NEED_IP(t + 3);
+
+        do* op++ = *ip++;
+
+        while (--t > 0);
+
         goto first_literal_run;
     }
 
@@ -97,8 +109,10 @@ DO_DECOMPRESS  ( const lzo_bytep in , lzo_uint  in_len,
     {
         NEED_IP(3);
         t = *ip++;
+
         if (t >= 16)
             goto match;
+
         /* a literal run */
         if (t == 0)
         {
@@ -109,47 +123,74 @@ DO_DECOMPRESS  ( const lzo_bytep in , lzo_uint  in_len,
                 TEST_IV(t);
                 NEED_IP(1);
             }
+
             t += 15 + *ip++;
         }
+
         /* copy literals */
-        assert(t > 0); NEED_OP(t+3); NEED_IP(t+6);
+        assert(t > 0);
+        NEED_OP(t + 3);
+        NEED_IP(t + 6);
 #if (LZO_OPT_UNALIGNED64) && (LZO_OPT_UNALIGNED32)
         t += 3;
+
         if (t >= 8) do
             {
-            UA_COPY8(op,ip);
-            op += 8; ip += 8; t -= 8;
-        } while (t >= 8);
+                UA_COPY8(op, ip);
+                op += 8;
+                ip += 8;
+                t -= 8;
+            }
+            while (t >= 8);
+
         if (t >= 4)
         {
-            UA_COPY4(op,ip);
-            op += 4; ip += 4; t -= 4;
+            UA_COPY4(op, ip);
+            op += 4;
+            ip += 4;
+            t -= 4;
         }
+
         if (t > 0)
         {
             *op++ = *ip++;
+
             if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } }
         }
+
 #elif (LZO_OPT_UNALIGNED32) || (LZO_ALIGNED_OK_4)
 #if !(LZO_OPT_UNALIGNED32)
-        if (PTR_ALIGNED2_4(op,ip))
+
+        if (PTR_ALIGNED2_4(op, ip))
         {
 #endif
-        UA_COPY4(op,ip);
-        op += 4; ip += 4;
+            UA_COPY4(op, ip);
+            op += 4;
+            ip += 4;
+
             if (--t > 0)
             {
                 if (t >= 4)
                 {
-                do {
-                    UA_COPY4(op,ip);
-                    op += 4; ip += 4; t -= 4;
-                } while (t >= 4);
-                if (t > 0) do *op++ = *ip++; while (--t > 0);
+                    do
+                    {
+                        UA_COPY4(op, ip);
+                        op += 4;
+                        ip += 4;
+                        t -= 4;
+                    }
+                    while (t >= 4);
+
+                    if (t > 0) do* op++ = *ip++;
+
+                        while (--t > 0);
                 }
                 else
-                do *op++ = *ip++; while (--t > 0);
+                    do* op++ = *ip++;
+
+                    while (--t > 0);
             }
+
 #if !(LZO_OPT_UNALIGNED32)
         }
         else
@@ -157,9 +198,15 @@ DO_DECOMPRESS  ( const lzo_bytep in , lzo_uint  in_len,
 #endif
 #if !(LZO_OPT_UNALIGNED32)
         {
-            *op++ = *ip++; *op++ = *ip++; *op++ = *ip++;
-            do *op++ = *ip++; while (--t > 0);
+            *op++ = *ip++;
+            *op++ = *ip++;
+            *op++ = *ip++;
+
+            do* op++ = *ip++;
+
+            while (--t > 0);
         }
+
 #endif
 
 
@@ -167,8 +214,10 @@ first_literal_run:
 
 
         t = *ip++;
+
         if (t >= 16)
             goto match;
+
 #if defined(COPY_DICT)
 #if defined(LZO1Z)
         m_off = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2);
@@ -177,7 +226,8 @@ first_literal_run:
         m_off = (1 + M2_MAX_OFFSET) + (t >> 2) + (*ip++ << 2);
 #endif
         NEED_OP(3);
-        t = 3; COPY_DICT(t,m_off)
+        t = 3;
+        COPY_DICT(t, m_off)
 #else /* !COPY_DICT */
 #if defined(LZO1Z)
         t = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2);
@@ -188,15 +238,20 @@ first_literal_run:
         m_pos -= t >> 2;
         m_pos -= *ip++ << 2;
 #endif
-        TEST_LB(m_pos); NEED_OP(3);
-        *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos;
+        TEST_LB(m_pos);
+        NEED_OP(3);
+        *op++ = *m_pos++;
+        *op++ = *m_pos++;
+        *op++ = *m_pos;
 #endif /* COPY_DICT */
         goto match_done;
 
 
         /* handle matches */
-        for (;;) {
+        for (;;)
+        {
 match:
+
             if (t >= 64)                /* a M2 match */
             {
 #if defined(COPY_DICT)
@@ -208,6 +263,7 @@ match:
                 t = (t >> 4) - 3;
 #elif defined(LZO1Z)
                 m_off = t & 0x1f;
+
                 if (m_off >= 0x1c)
                     m_off = last_m_off;
                 else
@@ -215,6 +271,7 @@ match:
                     m_off = 1 + (m_off << 6) + (*ip++ >> 2);
                     last_m_off = m_off;
                 }
+
                 t = (t >> 5) - 1;
 #endif
 #else /* !COPY_DICT */
@@ -232,6 +289,7 @@ match:
                 {
                     lzo_uint off = t & 0x1f;
                     m_pos = op;
+
                     if (off >= 0x1c)
                     {
                         assert(last_m_off > 0);
@@ -246,13 +304,16 @@ match:
                 }
                 t = (t >> 5) - 1;
 #endif
-                TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1);
+                TEST_LB(m_pos);
+                assert(t > 0);
+                NEED_OP(t + 3 - 1);
                 goto copy_match;
 #endif /* COPY_DICT */
             }
             else if (t >= 32)           /* a M3 match */
             {
                 t &= 31;
+
                 if (t == 0)
                 {
                     while (*ip == 0)
@@ -262,9 +323,11 @@ match:
                         TEST_OV(t);
                         NEED_IP(1);
                     }
+
                     t += 31 + *ip++;
                     NEED_IP(2);
                 }
+
 #if defined(COPY_DICT)
 #if defined(LZO1Z)
                 m_off = 1 + (ip[0] << 6) + (ip[1] >> 2);
@@ -298,6 +361,7 @@ match:
                 m_pos -= (t & 8) << 11;
 #endif /* COPY_DICT */
                 t &= 7;
+
                 if (t == 0)
                 {
                     while (*ip == 0)
@@ -307,9 +371,11 @@ match:
                         TEST_OV(t);
                         NEED_IP(1);
                     }
+
                     t += 7 + *ip++;
                     NEED_IP(2);
                 }
+
 #if defined(COPY_DICT)
 #if defined(LZO1Z)
                 m_off += (ip[0] << 6) + (ip[1] >> 2);
@@ -317,8 +383,10 @@ match:
                 m_off += (ip[0] >> 2) + (ip[1] << 6);
 #endif
                 ip += 2;
+
                 if (m_off == 0)
                     goto eof_found;
+
                 m_off += 0x4000;
 #if defined(LZO1Z)
                 last_m_off = m_off;
@@ -332,8 +400,10 @@ match:
                 m_pos -= (ip[0] >> 2) + (ip[1] << 6);
 #endif
                 ip += 2;
+
                 if (m_pos == op)
                     goto eof_found;
+
                 m_pos -= 0x4000;
 #if defined(LZO1Z)
                 last_m_off = pd((const lzo_bytep)op, m_pos);
@@ -350,7 +420,8 @@ match:
                 m_off = 1 + (t >> 2) + (*ip++ << 2);
 #endif
                 NEED_OP(2);
-                t = 2; COPY_DICT(t,m_off)
+                t = 2;
+                COPY_DICT(t, m_off)
 #else /* !COPY_DICT */
 #if defined(LZO1Z)
                 t = 1 + (t << 6) + (*ip++ >> 2);
@@ -361,8 +432,10 @@ match:
                 m_pos -= t >> 2;
                 m_pos -= *ip++ << 2;
 #endif
-                TEST_LB(m_pos); NEED_OP(2);
-                *op++ = *m_pos++; *op++ = *m_pos;
+                TEST_LB(m_pos);
+                NEED_OP(2);
+                *op++ = *m_pos++;
+                *op++ = *m_pos;
 #endif /* COPY_DICT */
                 goto match_done;
             }
@@ -370,56 +443,84 @@ match:
             /* copy match */
 #if defined(COPY_DICT)
 
-            NEED_OP(t+3-1);
-            t += 3-1; COPY_DICT(t,m_off)
+            NEED_OP(t + 3 - 1);
+            t += 3 - 1;
+            COPY_DICT(t, m_off)
 
 #else /* !COPY_DICT */
 
-            TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1);
+            TEST_LB(m_pos);
+            assert(t > 0);
+            NEED_OP(t + 3 - 1);
 #if (LZO_OPT_UNALIGNED64) && (LZO_OPT_UNALIGNED32)
+
             if (op - m_pos >= 8)
             {
                 t += (3 - 1);
+
                 if (t >= 8) do
                     {
-                    UA_COPY8(op,m_pos);
-                    op += 8; m_pos += 8; t -= 8;
-                } while (t >= 8);
+                        UA_COPY8(op, m_pos);
+                        op += 8;
+                        m_pos += 8;
+                        t -= 8;
+                    }
+                    while (t >= 8);
+
                 if (t >= 4)
                 {
-                    UA_COPY4(op,m_pos);
-                    op += 4; m_pos += 4; t -= 4;
+                    UA_COPY4(op, m_pos);
+                    op += 4;
+                    m_pos += 4;
+                    t -= 4;
                 }
+
                 if (t > 0)
                 {
                     *op++ = m_pos[0];
+
                     if (t > 1) { *op++ = m_pos[1]; if (t > 2) { *op++ = m_pos[2]; } }
                 }
             }
             else
 #elif (LZO_OPT_UNALIGNED32) || (LZO_ALIGNED_OK_4)
 #if !(LZO_OPT_UNALIGNED32)
-            if (t >= 2 * 4 - (3 - 1) && PTR_ALIGNED2_4(op,m_pos))
+            if (t >= 2 * 4 - (3 - 1) && PTR_ALIGNED2_4(op, m_pos))
             {
                 assert((op - m_pos) >= 4);  /* both pointers are aligned */
 #else
+
             if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4)
             {
 #endif
-                UA_COPY4(op,m_pos);
-                op += 4; m_pos += 4; t -= 4 - (3 - 1);
-                do {
-                    UA_COPY4(op,m_pos);
-                    op += 4; m_pos += 4; t -= 4;
-                } while (t >= 4);
-                if (t > 0) do *op++ = *m_pos++; while (--t > 0);
+                UA_COPY4(op, m_pos);
+                op += 4;
+                m_pos += 4;
+                t -= 4 - (3 - 1);
+
+                do
+                {
+                    UA_COPY4(op, m_pos);
+                    op += 4;
+                    m_pos += 4;
+                    t -= 4;
+                }
+                while (t >= 4);
+
+                if (t > 0) do* op++ = *m_pos++;
+
+                    while (--t > 0);
             }
             else
 #endif
             {
 copy_match:
-                *op++ = *m_pos++; *op++ = *m_pos++;
-                do *op++ = *m_pos++; while (--t > 0);
+                *op++ = *m_pos++;
+                *op++ = *m_pos++;
+
+                do* op++ = *m_pos++;
+
+                while (--t > 0);
             }
 
 #endif /* COPY_DICT */
@@ -430,17 +531,27 @@ match_done:
 #else
             t = ip[-2] & 3;
 #endif
+
             if (t == 0)
                 break;
 
             /* copy literals */
 match_next:
-            assert(t > 0); assert(t < 4); NEED_OP(t); NEED_IP(t+3);
+            assert(t > 0);
+            assert(t < 4);
+            NEED_OP(t);
+            NEED_IP(t + 3);
 #if 0
-            do *op++ = *ip++; while (--t > 0);
+
+            do* op++ = *ip++;
+
+            while (--t > 0);
+
 #else
             *op++ = *ip++;
+
             if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } }
+
 #endif
             t = *ip++;
         }

extern/lzo/src/lzo1x_d2.c

@@ -35,22 +35,22 @@
 
 #if defined(LZO_ARCH_I386) && defined(LZO_USE_ASM)
 LZO_EXTERN(int) lzo1x_decompress_asm_safe
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem);
 LZO_PUBLIC(int) lzo1x_decompress_asm_safe
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem)
 {
     return lzo1x_decompress_safe(src, src_len, dst, dst_len, wrkmem);
 }
 LZO_EXTERN(int) lzo1x_decompress_asm_fast_safe
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem);
 LZO_PUBLIC(int) lzo1x_decompress_asm_fast_safe
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem)
 {

extern/lzo/src/lzo1x_d3.c

@@ -81,7 +81,7 @@
 
 
 LZO_PUBLIC(int)
-lzo1x_decompress_dict_safe ( const lzo_bytep in,  lzo_uint  in_len,
+lzo1x_decompress_dict_safe(const lzo_bytep in,  lzo_uint  in_len,
                            lzo_bytep out, lzo_uintp out_len,
                            lzo_voidp wrkmem /* NOT USED */,
                            const lzo_bytep dict, lzo_uint dict_len)

extern/lzo/src/lzo1x_oo.ch

@@ -41,6 +41,7 @@ static void copy2(lzo_bytep ip, const lzo_bytep m_pos, lzo_uint off)
 {
     assert(off > 0);
     ip[0] = m_pos[0];
+
     if (off == 1)
         ip[1] = m_pos[0];
     else
@@ -52,6 +53,7 @@ static void copy3(lzo_bytep ip, const lzo_bytep m_pos, lzo_uint off)
 {
     assert(off > 0);
     ip[0] = m_pos[0];
+
     if (off == 1)
     {
         ip[2] = ip[1] = m_pos[0];
@@ -74,9 +76,9 @@ static void copy3(lzo_bytep ip, const lzo_bytep m_pos, lzo_uint off)
 ************************************************************************/
 
 LZO_PUBLIC(int)
-DO_OPTIMIZE          (       lzo_bytep in , lzo_uint  in_len,
+DO_OPTIMIZE(lzo_bytep in , lzo_uint  in_len,
             lzo_bytep out, lzo_uintp out_len,
-                             lzo_voidp wrkmem )
+            lzo_voidp wrkmem)
 {
     lzo_bytep op;
     lzo_bytep ip;
@@ -98,41 +100,57 @@ DO_OPTIMIZE          (       lzo_bytep in , lzo_uint  in_len,
     ip = in;
 
     assert(in_len >= 3);
+
     if (*ip > 17)
     {
         t = *ip++ - 17;
+
         if (t < 4)
             goto match_next;
+
         goto first_literal_run;
     }
+
     assert(*ip < 16 || (*ip == 17 && in_len == 3));
 
     while (TEST_IP_AND_TEST_OP)
     {
         t = *ip++;
+
         if (t >= 16)
             goto match;
+
         /* a literal run */
         litp = ip - 1;
+
         if (t == 0)
         {
             t = 15;
+
             while (*ip == 0)
                 t += 255, ip++;
+
             t += *ip++;
         }
+
         lit = t + 3;
         /* copy literals */
 copy_literal_run:
-        *op++ = *ip++; *op++ = *ip++; *op++ = *ip++;
+        *op++ = *ip++;
+        *op++ = *ip++;
+        *op++ = *ip++;
 first_literal_run:
-        do *op++ = *ip++; while (--t > 0);
+
+        do* op++ = *ip++;
+
+        while (--t > 0);
 
 
         t = *ip++;
 
         if (t >= 16)
             goto match;
+
 #if defined(LZO1X)
         m_pos = op - 1 - 0x800;
 #elif defined(LZO1Y)
@@ -140,13 +158,16 @@ first_literal_run:
 #endif
         m_pos -= t >> 2;
         m_pos -= *ip++ << 2;
-        *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos++;
+        *op++ = *m_pos++;
+        *op++ = *m_pos++;
+        *op++ = *m_pos++;
         lit = 0;
         goto match_done;
 
 
         /* handle matches */
-        do {
+        do
+        {
             if (t < 16)                     /* a M1 match */
             {
                 m_pos = op - 1;
@@ -161,6 +182,7 @@ first_literal_run:
                 assert(litp == ip - 2 - lit - 2);
                 assert((lzo_uint)(*litp & 3) == lit);
                 nl = ip[-2] & 3;
+
                 /* test if a match follows */
                 if (nl == 0 && lit == 1 && ip[0] >= 16)
                 {
@@ -169,7 +191,7 @@ first_literal_run:
                     lit += 2;
                     *litp = LZO_BYTE((*litp & ~3) | lit);
                     /* copy over the 2 literals that replace the match */
-                    copy2(ip-2,m_pos,pd(op,m_pos));
+                    copy2(ip - 2, m_pos, pd(op, m_pos));
                     o_m1_a++;
                 }
                 /* test if a literal run follows */
@@ -180,25 +202,32 @@ first_literal_run:
                     /* remove short run */
                     *litp &= ~3;
                     /* copy over the 2 literals that replace the match */
-                    copy2(ip-3+1,m_pos,pd(op,m_pos));
+                    copy2(ip - 3 + 1, m_pos, pd(op, m_pos));
                     /* move literals 1 byte ahead */
                     litp += 2;
+
                     if (lit > 0)
-                        lzo_memmove(litp+1,litp,lit);
+                        lzo_memmove(litp + 1, litp, lit);
+
                     /* insert new length of long literal run */
-                    lit += 2 + t + 3; assert(lit <= 18);
+                    lit += 2 + t + 3;
+                    assert(lit <= 18);
                     *litp = LZO_BYTE(lit - 3);
 
                     o_m1_b++;
-                    *op++ = *m_pos++; *op++ = *m_pos++;
+                    *op++ = *m_pos++;
+                    *op++ = *m_pos++;
                     goto copy_literal_run;
                 }
+
 copy_m1:
-                *op++ = *m_pos++; *op++ = *m_pos++;
+                *op++ = *m_pos++;
+                *op++ = *m_pos++;
             }
             else
             {
 match:
+
                 if (t >= 64)                /* a M2 match */
                 {
                     m_pos = op - 1;
@@ -211,10 +240,12 @@ match:
                     m_pos -= *ip++ << 2;
                     t = (t >> 4) - 3;
 #endif
+
                     if (litp == NULL)
                         goto copy_m;
 
                     nl = ip[-2] & 3;
+
                     /* test if in beetween two long literal runs */
                     if (t == 1 && lit > 3 && nl == 0 &&
                             ip[0] < 16 && ip[0] != 0 && (lit + 3 + ip[0] < 16))
@@ -222,12 +253,15 @@ match:
                         assert(*litp == lit - 3);
                         t = *ip++;
                         /* copy over the 3 literals that replace the match */
-                        copy3(ip-1-2,m_pos,pd(op,m_pos));
+                        copy3(ip - 1 - 2, m_pos, pd(op, m_pos));
                         /* set new length of previous literal run */
-                        lit += 3 + t + 3; assert(lit <= 18);
+                        lit += 3 + t + 3;
+                        assert(lit <= 18);
                         *litp = LZO_BYTE(lit - 3);
                         o_m2++;
-                        *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos++;
+                        *op++ = *m_pos++;
+                        *op++ = *m_pos++;
+                        *op++ = *m_pos++;
                         goto copy_literal_run;
                     }
                 }
@@ -236,13 +270,17 @@ match:
                     if (t >= 32)            /* a M3 match */
                     {
                         t &= 31;
+
                         if (t == 0)
                         {
                             t = 31;
+
                             while (*ip == 0)
                                 t += 255, ip++;
+
                             t += *ip++;
                         }
+
                         m_pos = op - 1;
                         m_pos -= *ip++ >> 2;
                         m_pos -= *ip++ << 6;
@@ -252,23 +290,31 @@ match:
                         m_pos = op;
                         m_pos -= (t & 8) << 11;
                         t &= 7;
+
                         if (t == 0)
                         {
                             t = 7;
+
                             while (*ip == 0)
                                 t += 255, ip++;
+
                             t += *ip++;
                         }
+
                         m_pos -= *ip++ >> 2;
                         m_pos -= *ip++ << 6;
+
                         if (m_pos == op)
                             goto eof_found;
+
                         m_pos -= 0x4000;
                     }
+
                     if (litp == NULL)
                         goto copy_m;
 
                     nl = ip[-2] & 3;
+
                     /* test if in beetween two matches */
                     if (t == 1 && lit == 0 && nl == 0 && ip[0] >= 16)
                     {
@@ -279,7 +325,7 @@ match:
                         lit += 3;
                         *litp = LZO_BYTE((*litp & ~3) | lit);
                         /* copy over the 3 literals that replace the match */
-                        copy3(ip-3,m_pos,pd(op,m_pos));
+                        copy3(ip - 3, m_pos, pd(op, m_pos));
                         o_m3_a++;
                     }
                     /* test if a literal run follows */
@@ -292,26 +338,37 @@ match:
                         /* remove short run */
                         *litp &= ~3;
                         /* copy over the 3 literals that replace the match */
-                        copy3(ip-4+1,m_pos,pd(op,m_pos));
+                        copy3(ip - 4 + 1, m_pos, pd(op, m_pos));
                         /* move literals 1 byte ahead */
                         litp += 2;
+
                         if (lit > 0)
-                            lzo_memmove(litp+1,litp,lit);
+                            lzo_memmove(litp + 1, litp, lit);
+
                         /* insert new length of long literal run */
-                        lit += 3 + t + 3; assert(lit <= 18);
+                        lit += 3 + t + 3;
+                        assert(lit <= 18);
                         *litp = LZO_BYTE(lit - 3);
 
                         o_m3_b++;
-                        *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos++;
+                        *op++ = *m_pos++;
+                        *op++ = *m_pos++;
+                        *op++ = *m_pos++;
                         goto copy_literal_run;
                     }
                 }
+
 copy_m:
-                *op++ = *m_pos++; *op++ = *m_pos++;
-                do *op++ = *m_pos++; while (--t > 0);
+                *op++ = *m_pos++;
+                *op++ = *m_pos++;
+
+                do* op++ = *m_pos++;
+
+                while (--t > 0);
             }
 
 match_done:
+
             if (next_lit == NO_LIT)
             {
                 t = ip[-2] & 3;
@@ -320,15 +377,23 @@ match_done:
             }
             else
                 t = next_lit;
+
             assert(t <= 3);
             next_lit = NO_LIT;
+
             if (t == 0)
                 break;
+
             /* copy literals */
 match_next:
-            do *op++ = *ip++; while (--t > 0);
+
+            do* op++ = *ip++;
+
+            while (--t > 0);
+
             t = *ip++;
-        } while (TEST_IP_AND_TEST_OP);
+        }
+        while (TEST_IP_AND_TEST_OP);
     }
 
     /* no EOF code was found */
@@ -341,8 +406,11 @@ eof_found:
     printf("optimize: %5lu %5lu   %5lu   %5lu %5lu\n",
            o_m1_a, o_m1_b, o_m2, o_m3_a, o_m3_b);
 #endif
-    LZO_UNUSED(o_m1_a); LZO_UNUSED(o_m1_b); LZO_UNUSED(o_m2);
-    LZO_UNUSED(o_m3_a); LZO_UNUSED(o_m3_b);
+    LZO_UNUSED(o_m1_a);
+    LZO_UNUSED(o_m1_b);
+    LZO_UNUSED(o_m2);
+    LZO_UNUSED(o_m3_a);
+    LZO_UNUSED(o_m3_b);
     *out_len = pd(op, out);
     return (ip == ip_end ? LZO_E_OK :
             (ip < ip_end  ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));

extern/lzo/src/lzo1y_d2.c

@@ -35,22 +35,22 @@
 
 #if defined(LZO_ARCH_I386) && defined(LZO_USE_ASM)
 LZO_EXTERN(int) lzo1y_decompress_asm_safe
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem);
 LZO_PUBLIC(int) lzo1y_decompress_asm_safe
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem)
 {
     return lzo1y_decompress_safe(src, src_len, dst, dst_len, wrkmem);
 }
 LZO_EXTERN(int) lzo1y_decompress_asm_fast_safe
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem);
 LZO_PUBLIC(int) lzo1y_decompress_asm_fast_safe
-                                (const lzo_bytep src, lzo_uint  src_len,
+(const lzo_bytep src, lzo_uint  src_len,
  lzo_bytep dst, lzo_uintp dst_len,
  lzo_voidp wrkmem)
 {

extern/lzo/src/lzo2a_9x.c

@@ -46,7 +46,7 @@
 
 #if (LZO_CC_BORLANDC && LZO_MM_FLAT)
 #  if ((__BORLANDC__) >= 0x0450 && (__BORLANDC__) < 0x0460)
-     /* avoid internal compiler error */
+/* avoid internal compiler error */
 #    pragma option -Od
 #  endif
 #endif
@@ -72,24 +72,24 @@
 ************************************************************************/
 
 LZO_EXTERN(int)
-lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
+lzo2a_999_compress_callback(const lzo_bytep in , lzo_uint  in_len,
                             lzo_bytep out, lzo_uintp out_len,
                             lzo_voidp wrkmem,
                             lzo_callback_p cb,
-                                    lzo_uint max_chain );
+                            lzo_uint max_chain);
 
 LZO_PUBLIC(int)
-lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
+lzo2a_999_compress_callback(const lzo_bytep in , lzo_uint  in_len,
                             lzo_bytep out, lzo_uintp out_len,
                             lzo_voidp wrkmem,
                             lzo_callback_p cb,
-                                    lzo_uint max_chain )
+                            lzo_uint max_chain)
 {
     lzo_bytep op;
     lzo_bytep bitp = 0;
     lzo_uint m_len, m_off;
     LZO_COMPRESS_T cc;
-    LZO_COMPRESS_T * const c = &cc;
+    LZO_COMPRESS_T* const c = &cc;
     lzo_swd_p const swd = (lzo_swd_p) wrkmem;
     int r;
 
@@ -107,15 +107,19 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
 
     op = out;
 
-    r = init_match(c,swd,NULL,0,0);
+    r = init_match(c, swd, NULL, 0, 0);
+
     if (r != 0)
         return r;
+
     if (max_chain > 0)
         swd->max_chain = max_chain;
 
-    r = find_match(c,swd,0,0);
+    r = find_match(c, swd, 0, 0);
+
     if (r != 0)
         return r;
+
     while (c->look > 0)
     {
         lzo_uint lazy_match_min_gain = 0;
@@ -129,6 +133,7 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
         m_off = c->m_off;
 
 #if (SWD_N >= 8192)
+
         if (m_off >= 8192)
         {
             if (m_len < M3_MIN_LEN)
@@ -164,11 +169,13 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
         {
             unsigned char lit = LZO_BYTE(swd->b_char);
 
-            r = find_match(c,swd,1,0);
-            assert(r == 0); LZO_UNUSED(r);
+            r = find_match(c, swd, 1, 0);
+            assert(r == 0);
+            LZO_UNUSED(r);
             assert(c->look > 0);
 
 #if (SWD_N >= 8192)
+
             if (m_off < 8192 && c->m_off >= 8192)
                 lazy_match_min_gain += extra1;
             else
@@ -179,6 +186,7 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
                             c->m_len <= M1_MAX_LEN && c->m_off <= 256))
                         lazy_match_min_gain += extra2;
                 }
+
             if (c->m_len >= M1_MIN_LEN &&
                     c->m_len <= M1_MAX_LEN && c->m_off <= 256)
             {
@@ -206,6 +214,7 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
             }
             else
                 ahead = 1;
+
             assert(m_len > 0);
         }
 
@@ -216,8 +225,9 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
             putbit(0);
             putbyte(swd->b_char);
             c->lit_bytes++;
-            r = find_match(c,swd,1,0);
-            assert(r == 0); LZO_UNUSED(r);
+            r = find_match(c, swd, 1, 0);
+            assert(r == 0);
+            LZO_UNUSED(r);
         }
         else
         {
@@ -230,10 +240,11 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
             {
                 putbit(1);
                 putbit(0);
-                putbits(2,m_len - M1_MIN_LEN);
+                putbits(2, m_len - M1_MIN_LEN);
                 putbyte(m_off - 1);
                 c->m1++;
             }
+
 #if (SWD_N >= 8192)
             else if (m_off >= 8192)
             {
@@ -245,14 +256,17 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
                 putbyte(m_off >> 5);
                 putbit(1);
                 len -= M3_MIN_LEN - 1;
+
                 while (len > 255)
                 {
                     len -= 255;
                     putbyte(0);
                 }
+
                 putbyte(len);
                 c->m4++;
             }
+
 #endif
             else
             {
@@ -260,6 +274,7 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
 
                 putbit(1);
                 putbit(1);
+
                 if (m_len <= 9)
                 {
                     putbyte(((m_len - 2) << 5) | (m_off & 31));
@@ -275,17 +290,21 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
                     putbit(0);
 #endif
                     len -= 10 - 1;
+
                     while (len > 255)
                     {
                         len -= 255;
                         putbyte(0);
                     }
+
                     putbyte(len);
                     c->m3++;
                 }
             }
-            r = find_match(c,swd,m_len,1+ahead);
-            assert(r == 0); LZO_UNUSED(r);
+
+            r = find_match(c, swd, m_len, 1 + ahead);
+            assert(r == 0);
+            LZO_UNUSED(r);
         }
 
         c->codesize = pd(op, out);
@@ -301,6 +320,7 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
 
     /* flush remaining bits */
     assert(k < CHAR_BIT);
+
     if (k > 0)
     {
         assert(b == MASKBITS(k));
@@ -334,11 +354,11 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint  in_len,
 ************************************************************************/
 
 LZO_PUBLIC(int)
-lzo2a_999_compress  ( const lzo_bytep in , lzo_uint  in_len,
+lzo2a_999_compress(const lzo_bytep in , lzo_uint  in_len,
                    lzo_bytep out, lzo_uintp out_len,
-                            lzo_voidp wrkmem )
+                   lzo_voidp wrkmem)
 {
-    return lzo2a_999_compress_callback(in,in_len,out,out_len,wrkmem,
+    return lzo2a_999_compress_callback(in, in_len, out, out_len, wrkmem,
                                        (lzo_callback_p) 0, 0);
 }
 

extern/lzo/src/lzo2a_d.ch

@@ -37,9 +37,9 @@
 #define _NEXTBYTE   (*ip++)
 
 LZO_PUBLIC(int)
-DO_DECOMPRESS    ( const lzo_bytep in , lzo_uint  in_len,
+DO_DECOMPRESS(const lzo_bytep in , lzo_uint  in_len,
               lzo_bytep out, lzo_uintp out_len,
-                         lzo_voidp wrkmem )
+              lzo_voidp wrkmem)
 {
     lzo_bytep op;
     const lzo_bytep ip;
@@ -62,17 +62,21 @@ DO_DECOMPRESS    ( const lzo_bytep in , lzo_uint  in_len,
     while (TEST_IP_AND_TEST_OP)
     {
         NEEDBITS(1);
+
         if (MASKBITS(1) == 0)
         {
             DUMPBITS(1);
             /* a literal */
-            NEED_IP(1); NEED_OP(1);
+            NEED_IP(1);
+            NEED_OP(1);
             *op++ = *ip++;
             continue;
         }
+
         DUMPBITS(1);
 
         NEEDBITS(1);
+
         if (MASKBITS(1) == 0)
         {
             DUMPBITS(1);
@@ -80,26 +84,31 @@ DO_DECOMPRESS    ( const lzo_bytep in , lzo_uint  in_len,
             NEEDBITS(2);
             t = M1_MIN_LEN + (lzo_uint) MASKBITS(2);
             DUMPBITS(2);
-            NEED_IP(1); NEED_OP(t);
+            NEED_IP(1);
+            NEED_OP(t);
             m_pos = op - 1 - *ip++;
-            assert(m_pos >= out); assert(m_pos < op);
+            assert(m_pos >= out);
+            assert(m_pos < op);
             TEST_LB(m_pos);
-            MEMCPY_DS(op,m_pos,t);
+            MEMCPY_DS(op, m_pos, t);
             continue;
         }
+
         DUMPBITS(1);
 
         NEED_IP(2);
         t = *ip++;
         m_pos = op;
-        m_pos -= (t & 31) | (((lzo_uint) *ip++) << 5);
+        m_pos -= (t & 31) | (((lzo_uint) * ip++) << 5);
         t >>= 5;
+
         if (t == 0)
         {
 #if (SWD_N >= 8192)
             NEEDBITS(1);
             t = MASKBITS(1);
             DUMPBITS(1);
+
             if (t == 0)
                 t = 10 - 1;
             else
@@ -108,10 +117,12 @@ DO_DECOMPRESS    ( const lzo_bytep in , lzo_uint  in_len,
                 m_pos -= 8192;      /* t << 13 */
                 t = M3_MIN_LEN - 1;
             }
+
 #else
             t = 10 - 1;
 #endif
             NEED_IP(1);
+
             while (*ip == 0)
             {
                 t += 255;
@@ -119,20 +130,25 @@ DO_DECOMPRESS    ( const lzo_bytep in , lzo_uint  in_len,
                 TEST_OV(t);
                 NEED_IP(1);
             }
+
             t += *ip++;
         }
         else
         {
 #if defined(LZO_EOF_CODE)
+
             if (m_pos == op)
                 goto eof_found;
+
 #endif
             t += 2;
         }
-        assert(m_pos >= out); assert(m_pos < op);
+
+        assert(m_pos >= out);
+        assert(m_pos < op);
         TEST_LB(m_pos);
         NEED_OP(t);
-        MEMCPY_DS(op,m_pos,t);
+        MEMCPY_DS(op, m_pos, t);
     }
 
 

extern/lzo/src/lzo_conf.h

@@ -47,7 +47,7 @@
 #  error "include this file first"
 #endif
 #if defined(LZO_CFG_BUILD_DLL) && (LZO_CFG_BUILD_DLL+0) && !defined(__LZO_EXPORT1) && !defined(__LZO_EXPORT2) && 0
-  /* idea: we could auto-define __LZO_EXPORT1 for DLL exports */
+/* idea: we could auto-define __LZO_EXPORT1 for DLL exports */
 #ifndef __LZODEFS_H_INCLUDED
 #if defined(LZO_HAVE_CONFIG_H)
 #  include <config.h>
@@ -56,8 +56,8 @@
 #include <stddef.h>
 #include <lzo/lzodefs.h>
 #endif
-  /* #define __LZO_EXPORT1 __attribute__((__visibility__("default"))) */
-  /* #define __LZO_EXPORT1 __declspec(dllexport) */
+/* #define __LZO_EXPORT1 __attribute__((__visibility__("default"))) */
+/* #define __LZO_EXPORT1 __declspec(dllexport) */
 #endif
 #include <lzo/lzoconf.h>
 #if defined(LZO_CFG_EXTRA_CONFIG_HEADER2)
@@ -75,24 +75,24 @@
 ************************************************************************/
 
 #if (LZO_CC_MSC && (_MSC_VER >= 1000 && _MSC_VER < 1100))
-   /* disable bogus "unreachable code" warnings */
+/* disable bogus "unreachable code" warnings */
 #  pragma warning(disable: 4702)
 #endif
 #if (LZO_CC_MSC && (_MSC_VER >= 1000))
 #  pragma warning(disable: 4127 4701)
-   /* disable warnings about inlining */
+/* disable warnings about inlining */
 #  pragma warning(disable: 4514 4710 4711)
 #endif
 #if (LZO_CC_MSC && (_MSC_VER >= 1300))
-   /* disable '-Wall' warnings in system header files */
+/* disable '-Wall' warnings in system header files */
 #  pragma warning(disable: 4820)
 #endif
 #if (LZO_CC_MSC && (_MSC_VER >= 1800))
-   /* disable '-Wall' warnings in system header files */
+/* disable '-Wall' warnings in system header files */
 #  pragma warning(disable: 4746)
 #endif
 #if (LZO_CC_INTELC && (__INTEL_COMPILER >= 900))
-   /* disable pedantic warnings in system header files */
+/* disable pedantic warnings in system header files */
 #  pragma warning(disable: 1684)
 #endif
 
@@ -277,7 +277,7 @@ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint64_t) == 8)
 
 #if !defined(DMUL)
 #if 0
-   /* 32*32 multiplies may be faster than 64*64 on some 64-bit machines,
+/* 32*32 multiplies may be faster than 64*64 on some 64-bit machines,
  * but then we need extra casts from unsigned<->size_t */
 #  define DMUL(a,b) ((lzo_xint) ((lzo_uint32_t)(a) * (lzo_uint32_t)(b)))
 #else

extern/lzo/src/lzo_crc.c

@@ -35,7 +35,8 @@
 // see http://www.zlib.org/
 ************************************************************************/
 
-static const lzo_uint32_t lzo_crc32_table[256] = {
+static const lzo_uint32_t lzo_crc32_table[256] =
+{
     0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
     0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
     0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
@@ -119,25 +120,29 @@ lzo_crc32(lzo_uint32_t c, const lzo_bytep buf, lzo_uint len)
 #if 1
 #  define table lzo_crc32_table
 #else
-   const lzo_uint32_t * table = lzo_crc32_table;
+    const lzo_uint32_t* table = lzo_crc32_table;
 #endif
 
     if (buf == NULL)
         return 0;
 
     crc = (c & LZO_UINT32_C(0xffffffff)) ^ LZO_UINT32_C(0xffffffff);
+
     if (len >= 16) do
         {
-        LZO_DO16(buf,0);
+            LZO_DO16(buf, 0);
             buf += 16;
             len -= 16;
-    } while (len >= 16);
+        }
+        while (len >= 16);
+
     if (len != 0) do
         {
-        LZO_DO1(buf,0);
+            LZO_DO1(buf, 0);
             buf += 1;
             len -= 1;
-    } while (len > 0);
+        }
+        while (len > 0);
 
     return crc ^ LZO_UINT32_C(0xffffffff);
 #undef table

extern/lzo/src/lzo_dict.h

@@ -152,11 +152,11 @@ extern "C" {
 
 
 #if (LZO_HASH == LZO_HASH_GZIP)
-   /* hash function like in gzip/zlib (deflate) */
+/* hash function like in gzip/zlib (deflate) */
 #  define _DINDEX(dv,p)     (_DV_A((p),DL_SHIFT))
 
 #elif (LZO_HASH == LZO_HASH_GZIP_INCREMENTAL)
-   /* incremental hash like in gzip/zlib (deflate) */
+/* incremental hash like in gzip/zlib (deflate) */
 #  define __LZO_HASH_INCREMENTAL 1
 #  define DVAL_FIRST(dv,p)  dv = _DV_A((p),DL_SHIFT)
 #  define DVAL_NEXT(dv,p)   dv = (((dv) << DL_SHIFT) ^ p[2])
@@ -164,7 +164,7 @@ extern "C" {
 #  define DVAL_LOOKAHEAD    DL_MIN_LEN
 
 #elif (LZO_HASH == LZO_HASH_LZO_INCREMENTAL_A)
-   /* incremental LZO hash version A */
+/* incremental LZO hash version A */
 #  define __LZO_HASH_INCREMENTAL 1
 #  define DVAL_FIRST(dv,p)  dv = _DV_A((p),5)
 #  define DVAL_NEXT(dv,p) \
@@ -173,7 +173,7 @@ extern "C" {
 #  define DVAL_LOOKAHEAD    DL_MIN_LEN
 
 #elif (LZO_HASH == LZO_HASH_LZO_INCREMENTAL_B)
-   /* incremental LZO hash version B */
+/* incremental LZO hash version B */
 #  define __LZO_HASH_INCREMENTAL 1
 #  define DVAL_FIRST(dv,p)  dv = _DV_B((p),5)
 #  define DVAL_NEXT(dv,p) \
@@ -215,8 +215,8 @@ static void
 DVAL_ASSERT(lzo_xint dv, const lzo_bytep p)
 {
     lzo_xint df;
-    DVAL_FIRST(df,(p));
-    assert(DINDEX(dv,p) == DINDEX(df,p));
+    DVAL_FIRST(df, (p));
+    assert(DINDEX(dv, p) == DINDEX(df, p));
 }
 #else
 #  define DVAL_ASSERT(dv,p) ((void) 0)

extern/lzo/src/lzo_dll.ch

@@ -34,13 +34,16 @@
 
 /* don't pull in <windows.h> - we don't need it */
 #if 0
-BOOL FAR PASCAL LibMain ( HANDLE hInstance, WORD wDataSegment,
-                          WORD wHeapSize, LPSTR lpszCmdLine )
+BOOL FAR PASCAL LibMain(HANDLE hInstance, WORD wDataSegment,
+                        WORD wHeapSize, LPSTR lpszCmdLine)
 #else
-int __far __pascal LibMain ( int a, short b, short c, long d )
+int __far __pascal LibMain(int a, short b, short c, long d)
 #endif
 {
-    LZO_UNUSED(a); LZO_UNUSED(b); LZO_UNUSED(c); LZO_UNUSED(d);
+    LZO_UNUSED(a);
+    LZO_UNUSED(b);
+    LZO_UNUSED(c);
+    LZO_UNUSED(d);
     return 1;
 }
 

extern/lzo/src/lzo_func.h

@@ -64,21 +64,28 @@
 __lzo_static_forceinline unsigned lzo_bitops_ctlz32_func(lzo_uint32_t v)
 {
 #if (LZO_BITOPS_USE_MSC_BITSCAN) && (LZO_ARCH_AMD64 || LZO_ARCH_I386)
-    unsigned long r; (void) _BitScanReverse(&r, v); return (unsigned) r ^ 31;
+    unsigned long r;
+    (void) _BitScanReverse(&r, v);
+    return (unsigned) r ^ 31;
 #define lzo_bitops_ctlz32(v)    lzo_bitops_ctlz32_func(v)
 #elif (LZO_BITOPS_USE_ASM_BITSCAN) && (LZO_ARCH_AMD64 || LZO_ARCH_I386) && (LZO_ASM_SYNTAX_GNUC)
     lzo_uint32_t r;
-    __asm__("bsr %1,%0" : "=r" (r) : "rm" (v) __LZO_ASM_CLOBBER_LIST_CC);
+    __asm__("bsr %1,%0" : "=r"(r) : "rm"(v) __LZO_ASM_CLOBBER_LIST_CC);
     return (unsigned) r ^ 31;
 #define lzo_bitops_ctlz32(v)    lzo_bitops_ctlz32_func(v)
 #elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_INT == 4)
-    unsigned r; r = (unsigned) __builtin_clz(v); return r;
+    unsigned r;
+    r = (unsigned) __builtin_clz(v);
+    return r;
 #define lzo_bitops_ctlz32(v)    ((unsigned) __builtin_clz(v))
 #elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_LONG == 8) && (LZO_WORDSIZE >= 8)
-    unsigned r; r = (unsigned) __builtin_clzl(v); return r ^ 32;
+    unsigned r;
+    r = (unsigned) __builtin_clzl(v);
+    return r ^ 32;
 #define lzo_bitops_ctlz32(v)    (((unsigned) __builtin_clzl(v)) ^ 32)
 #else
-    LZO_UNUSED(v); return 0;
+    LZO_UNUSED(v);
+    return 0;
 #endif
 }
 
@@ -86,21 +93,28 @@ __lzo_static_forceinline unsigned lzo_bitops_ctlz32_func(lzo_uint32_t v)
 __lzo_static_forceinline unsigned lzo_bitops_ctlz64_func(lzo_uint64_t v)
 {
 #if (LZO_BITOPS_USE_MSC_BITSCAN) && (LZO_ARCH_AMD64)
-    unsigned long r; (void) _BitScanReverse64(&r, v); return (unsigned) r ^ 63;
+    unsigned long r;
+    (void) _BitScanReverse64(&r, v);
+    return (unsigned) r ^ 63;
 #define lzo_bitops_ctlz64(v)    lzo_bitops_ctlz64_func(v)
 #elif (LZO_BITOPS_USE_ASM_BITSCAN) && (LZO_ARCH_AMD64) && (LZO_ASM_SYNTAX_GNUC)
     lzo_uint64_t r;
-    __asm__("bsr %1,%0" : "=r" (r) : "rm" (v) __LZO_ASM_CLOBBER_LIST_CC);
+    __asm__("bsr %1,%0" : "=r"(r) : "rm"(v) __LZO_ASM_CLOBBER_LIST_CC);
     return (unsigned) r ^ 63;
 #define lzo_bitops_ctlz64(v)    lzo_bitops_ctlz64_func(v)
 #elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_LONG == 8) && (LZO_WORDSIZE >= 8)
-    unsigned r; r = (unsigned) __builtin_clzl(v); return r;
+    unsigned r;
+    r = (unsigned) __builtin_clzl(v);
+    return r;
 #define lzo_bitops_ctlz64(v)    ((unsigned) __builtin_clzl(v))
 #elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_LONG_LONG == 8) && (LZO_WORDSIZE >= 8)
-    unsigned r; r = (unsigned) __builtin_clzll(v); return r;
+    unsigned r;
+    r = (unsigned) __builtin_clzll(v);
+    return r;
 #define lzo_bitops_ctlz64(v)    ((unsigned) __builtin_clzll(v))
 #else
-    LZO_UNUSED(v); return 0;
+    LZO_UNUSED(v);
+    return 0;
 #endif
 }
 #endif
@@ -108,18 +122,23 @@ __lzo_static_forceinline unsigned lzo_bitops_ctlz64_func(lzo_uint64_t v)
 __lzo_static_forceinline unsigned lzo_bitops_cttz32_func(lzo_uint32_t v)
 {
 #if (LZO_BITOPS_USE_MSC_BITSCAN) && (LZO_ARCH_AMD64 || LZO_ARCH_I386)
-    unsigned long r; (void) _BitScanForward(&r, v); return (unsigned) r;
+    unsigned long r;
+    (void) _BitScanForward(&r, v);
+    return (unsigned) r;
 #define lzo_bitops_cttz32(v)    lzo_bitops_cttz32_func(v)
 #elif (LZO_BITOPS_USE_ASM_BITSCAN) && (LZO_ARCH_AMD64 || LZO_ARCH_I386) && (LZO_ASM_SYNTAX_GNUC)
     lzo_uint32_t r;
-    __asm__("bsf %1,%0" : "=r" (r) : "rm" (v) __LZO_ASM_CLOBBER_LIST_CC);
+    __asm__("bsf %1,%0" : "=r"(r) : "rm"(v) __LZO_ASM_CLOBBER_LIST_CC);
     return (unsigned) r;
 #define lzo_bitops_cttz32(v)    lzo_bitops_cttz32_func(v)
 #elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_INT >= 4)
-    unsigned r; r = (unsigned) __builtin_ctz(v); return r;
+    unsigned r;
+    r = (unsigned) __builtin_ctz(v);
+    return r;
 #define lzo_bitops_cttz32(v)    ((unsigned) __builtin_ctz(v))
 #else
-    LZO_UNUSED(v); return 0;
+    LZO_UNUSED(v);
+    return 0;
 #endif
 }
 
@@ -127,21 +146,28 @@ __lzo_static_forceinline unsigned lzo_bitops_cttz32_func(lzo_uint32_t v)
 __lzo_static_forceinline unsigned lzo_bitops_cttz64_func(lzo_uint64_t v)
 {
 #if (LZO_BITOPS_USE_MSC_BITSCAN) && (LZO_ARCH_AMD64)
-    unsigned long r; (void) _BitScanForward64(&r, v); return (unsigned) r;
+    unsigned long r;
+    (void) _BitScanForward64(&r, v);
+    return (unsigned) r;
 #define lzo_bitops_cttz64(v)    lzo_bitops_cttz64_func(v)
 #elif (LZO_BITOPS_USE_ASM_BITSCAN) && (LZO_ARCH_AMD64) && (LZO_ASM_SYNTAX_GNUC)
     lzo_uint64_t r;
-    __asm__("bsf %1,%0" : "=r" (r) : "rm" (v) __LZO_ASM_CLOBBER_LIST_CC);
+    __asm__("bsf %1,%0" : "=r"(r) : "rm"(v) __LZO_ASM_CLOBBER_LIST_CC);
     return (unsigned) r;
 #define lzo_bitops_cttz64(v)    lzo_bitops_cttz64_func(v)
 #elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_LONG >= 8) && (LZO_WORDSIZE >= 8)
-    unsigned r; r = (unsigned) __builtin_ctzl(v); return r;
+    unsigned r;
+    r = (unsigned) __builtin_ctzl(v);
+    return r;
 #define lzo_bitops_cttz64(v)    ((unsigned) __builtin_ctzl(v))
 #elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_LONG_LONG >= 8) && (LZO_WORDSIZE >= 8)
-    unsigned r; r = (unsigned) __builtin_ctzll(v); return r;
+    unsigned r;
+    r = (unsigned) __builtin_ctzll(v);
+    return r;
 #define lzo_bitops_cttz64(v)    ((unsigned) __builtin_ctzll(v))
 #else
-    LZO_UNUSED(v); return 0;
+    LZO_UNUSED(v);
+    return 0;
 #endif
 }
 #endif
@@ -179,7 +205,7 @@ lzo_unused_funcs_impl(void, lzo_bitops_unused_funcs)(void)
 typedef lzo_uint16_t __lzo_may_alias lzo_memops_TU2;
 #define lzo_memops_TU2p volatile lzo_memops_TU2 *
 #elif defined(__lzo_byte_struct)
-__lzo_byte_struct(lzo_memops_TU2_struct,2)
+__lzo_byte_struct(lzo_memops_TU2_struct, 2)
 typedef struct lzo_memops_TU2_struct lzo_memops_TU2;
 #else
 struct lzo_memops_TU2_struct { unsigned char a[2]; } __lzo_may_alias;
@@ -194,7 +220,7 @@ typedef struct lzo_memops_TU2_struct lzo_memops_TU2;
 typedef lzo_uint32_t __lzo_may_alias lzo_memops_TU4;
 #define lzo_memops_TU4p volatile lzo_memops_TU4 __LZO_MMODEL *
 #elif defined(__lzo_byte_struct)
-__lzo_byte_struct(lzo_memops_TU4_struct,4)
+__lzo_byte_struct(lzo_memops_TU4_struct, 4)
 typedef struct lzo_memops_TU4_struct lzo_memops_TU4;
 #else
 struct lzo_memops_TU4_struct { unsigned char a[4]; } __lzo_may_alias;
@@ -209,7 +235,7 @@ typedef struct lzo_memops_TU4_struct lzo_memops_TU4;
 typedef lzo_uint64_t __lzo_may_alias lzo_memops_TU8;
 #define lzo_memops_TU8p volatile lzo_memops_TU8 __LZO_MMODEL *
 #elif defined(__lzo_byte_struct)
-__lzo_byte_struct(lzo_memops_TU8_struct,8)
+__lzo_byte_struct(lzo_memops_TU8_struct, 8)
 typedef struct lzo_memops_TU8_struct lzo_memops_TU8;
 #else
 struct lzo_memops_TU8_struct { unsigned char a[8]; } __lzo_may_alias;
@@ -276,10 +302,10 @@ typedef struct lzo_memops_TU8_struct lzo_memops_TU8;
     d__8[0] = s__8[0]; d__8[1] = s__8[1]; d__8[2] = s__8[2]; d__8[3] = s__8[3]; \
     d__8[4] = s__8[4]; d__8[5] = s__8[5]; d__8[6] = s__8[6]; d__8[7] = s__8[7]; \
     LZO_BLOCK_END
-LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU1p)0)==1)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU1p)0) == 1)
 #define LZO_MEMOPS_COPY1(dd,ss) LZO_MEMOPS_MOVE1(dd,ss)
 #if (LZO_OPT_UNALIGNED16)
-LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU2p)0)==2)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU2p)0) == 2)
 #define LZO_MEMOPS_COPY2(dd,ss) \
     * (lzo_memops_TU2p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU2p) (const lzo_memops_TU0p) (ss)
 #elif defined(lzo_memops_tcheck__)
@@ -291,7 +317,7 @@ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU2p)0)==2)
 #define LZO_MEMOPS_COPY2(dd,ss) LZO_MEMOPS_MOVE2(dd,ss)
 #endif
 #if (LZO_OPT_UNALIGNED32)
-LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU4p)0)==4)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU4p)0) == 4)
 #define LZO_MEMOPS_COPY4(dd,ss) \
     * (lzo_memops_TU4p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU4p) (const lzo_memops_TU0p) (ss)
 #elif defined(lzo_memops_tcheck__)
@@ -307,7 +333,7 @@ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU4p)0)==4)
     LZO_BLOCK_BEGIN LZO_MEMOPS_COPY4(dd,ss); LZO_MEMOPS_COPY4((lzo_memops_TU1p)(lzo_memops_TU0p)(dd)+4,(const lzo_memops_TU1p)(const lzo_memops_TU0p)(ss)+4); LZO_BLOCK_END
 #else
 #if (LZO_OPT_UNALIGNED64)
-LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU8p)0)==8)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU8p)0) == 8)
 #define LZO_MEMOPS_COPY8(dd,ss) \
     * (lzo_memops_TU8p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss)
 #elif (LZO_OPT_UNALIGNED32)
@@ -340,11 +366,11 @@ __lzo_static_forceinline lzo_uint16_t lzo_memops_get_le16(const lzo_voidp ss)
 #elif (LZO_OPT_UNALIGNED16 && LZO_ARCH_POWERPC && LZO_ABI_BIG_ENDIAN) && (LZO_ASM_SYNTAX_GNUC)
     const lzo_memops_TU2p s = (const lzo_memops_TU2p) ss;
     unsigned long vv;
-    __asm__("lhbrx %0,0,%1" : "=r" (vv) : "r" (s), "m" (*s));
+    __asm__("lhbrx %0,0,%1" : "=r"(vv) : "r"(s), "m"(*s));
     v = (lzo_uint16_t) vv;
 #else
     const lzo_memops_TU1p s = (const lzo_memops_TU1p) ss;
-    v = (lzo_uint16_t) (((lzo_uint16_t)s[0]) | ((lzo_uint16_t)s[1] << 8));
+    v = (lzo_uint16_t)(((lzo_uint16_t)s[0]) | ((lzo_uint16_t)s[1] << 8));
 #endif
     return v;
 }
@@ -362,11 +388,11 @@ __lzo_static_forceinline lzo_uint32_t lzo_memops_get_le32(const lzo_voidp ss)
 #elif (LZO_OPT_UNALIGNED32 && LZO_ARCH_POWERPC && LZO_ABI_BIG_ENDIAN) && (LZO_ASM_SYNTAX_GNUC)
     const lzo_memops_TU4p s = (const lzo_memops_TU4p) ss;
     unsigned long vv;
-    __asm__("lwbrx %0,0,%1" : "=r" (vv) : "r" (s), "m" (*s));
+    __asm__("lwbrx %0,0,%1" : "=r"(vv) : "r"(s), "m"(*s));
     v = (lzo_uint32_t) vv;
 #else
     const lzo_memops_TU1p s = (const lzo_memops_TU1p) ss;
-    v = (lzo_uint32_t) (((lzo_uint32_t)s[0]) | ((lzo_uint32_t)s[1] << 8) | ((lzo_uint32_t)s[2] << 16) | ((lzo_uint32_t)s[3] << 24));
+    v = (lzo_uint32_t)(((lzo_uint32_t)s[0]) | ((lzo_uint32_t)s[1] << 8) | ((lzo_uint32_t)s[2] << 16) | ((lzo_uint32_t)s[3] << 24));
 #endif
     return v;
 }
@@ -387,7 +413,7 @@ __lzo_static_forceinline lzo_uint16_t lzo_memops_get_ne16(const lzo_voidp ss)
     return v;
 }
 #if (LZO_OPT_UNALIGNED16)
-LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU2p)0)==2)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU2p)0) == 2)
 #define LZO_MEMOPS_GET_NE16(ss)    (* (const lzo_memops_TU2p) (const lzo_memops_TU0p) (ss))
 #else
 #define LZO_MEMOPS_GET_NE16(ss)    lzo_memops_get_ne16(ss)
@@ -400,14 +426,14 @@ __lzo_static_forceinline lzo_uint32_t lzo_memops_get_ne32(const lzo_voidp ss)
     return v;
 }
 #if (LZO_OPT_UNALIGNED32)
-LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU4p)0)==4)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU4p)0) == 4)
 #define LZO_MEMOPS_GET_NE32(ss)    (* (const lzo_memops_TU4p) (const lzo_memops_TU0p) (ss))
 #else
 #define LZO_MEMOPS_GET_NE32(ss)    lzo_memops_get_ne32(ss)
 #endif
 
 #if (LZO_OPT_UNALIGNED64)
-LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU8p)0)==8)
+LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU8p)0) == 8)
 #define LZO_MEMOPS_GET_NE64(ss)    (* (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss))
 #endif
 
@@ -418,10 +444,10 @@ __lzo_static_forceinline void lzo_memops_put_le16(lzo_voidp dd, lzo_uint16_t vv)
 #elif (LZO_OPT_UNALIGNED16 && LZO_ARCH_POWERPC && LZO_ABI_BIG_ENDIAN) && (LZO_ASM_SYNTAX_GNUC)
     lzo_memops_TU2p d = (lzo_memops_TU2p) dd;
     unsigned long v = vv;
-    __asm__("sthbrx %2,0,%1" : "=m" (*d) : "r" (d), "r" (v));
+    __asm__("sthbrx %2,0,%1" : "=m"(*d) : "r"(d), "r"(v));
 #else
     lzo_memops_TU1p d = (lzo_memops_TU1p) dd;
-    d[0] = LZO_BYTE((vv      ) & 0xff);
+    d[0] = LZO_BYTE((vv) & 0xff);
     d[1] = LZO_BYTE((vv >>  8) & 0xff);
 #endif
 }
@@ -438,10 +464,10 @@ __lzo_static_forceinline void lzo_memops_put_le32(lzo_voidp dd, lzo_uint32_t vv)
 #elif (LZO_OPT_UNALIGNED32 && LZO_ARCH_POWERPC && LZO_ABI_BIG_ENDIAN) && (LZO_ASM_SYNTAX_GNUC)
     lzo_memops_TU4p d = (lzo_memops_TU4p) dd;
     unsigned long v = vv;
-    __asm__("stwbrx %2,0,%1" : "=m" (*d) : "r" (d), "r" (v));
+    __asm__("stwbrx %2,0,%1" : "=m"(*d) : "r"(d), "r"(v));
 #else
     lzo_memops_TU1p d = (lzo_memops_TU1p) dd;
-    d[0] = LZO_BYTE((vv      ) & 0xff);
+    d[0] = LZO_BYTE((vv) & 0xff);
     d[1] = LZO_BYTE((vv >>  8) & 0xff);
     d[2] = LZO_BYTE((vv >> 16) & 0xff);
     d[3] = LZO_BYTE((vv >> 24) & 0xff);

extern/lzo/src/lzo_init.c

@@ -48,14 +48,14 @@
 #undef LZOCHK_ASSERT
 #include "lzo_supp.h"
 
-    LZOCHK_ASSERT((LZO_UINT32_C(1) << (int)(8*sizeof(LZO_UINT32_C(1))-1)) > 0)
-    LZOCHK_ASSERT_IS_SIGNED_T(lzo_int)
-    LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint)
+LZOCHK_ASSERT((LZO_UINT32_C(1) << (int)(8 * sizeof(LZO_UINT32_C(1)) - 1)) > 0)
+LZOCHK_ASSERT_IS_SIGNED_T(lzo_int)
+LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint)
 #if !(__LZO_UINTPTR_T_IS_POINTER)
-    LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uintptr_t)
+LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uintptr_t)
 #endif
-    LZOCHK_ASSERT(sizeof(lzo_uintptr_t) >= sizeof(lzo_voidp))
-    LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_xint)
+LZOCHK_ASSERT(sizeof(lzo_uintptr_t) >= sizeof(lzo_voidp))
+LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_xint)
 
 #endif
 #undef LZOCHK_ASSERT
@@ -65,9 +65,10 @@
 //
 ************************************************************************/
 
-union lzo_config_check_union {
+union lzo_config_check_union
+{
     lzo_uint a[2];
-    unsigned char b[2*LZO_MAX(8,sizeof(lzo_uint))];
+    unsigned char b[2 * LZO_MAX(8, sizeof(lzo_uint))];
 #if defined(lzo_uint64_t)
     lzo_uint64_t c[2];
 #endif
@@ -79,7 +80,7 @@ union lzo_config_check_union {
 #else
 static __lzo_noinline lzo_voidp u2p(lzo_voidp ptr, lzo_uint off)
 {
-    return (lzo_voidp) ((lzo_bytep) ptr + off);
+    return (lzo_voidp)((lzo_bytep) ptr + off);
 }
 #endif
 
@@ -102,17 +103,20 @@ _lzo_config_check(void)
     r &= ((* (lzo_bytep) p) == 0);
 #if !(LZO_CFG_NO_CONFIG_CHECK)
 #if (LZO_ABI_BIG_ENDIAN)
-    u.a[0] = u.a[1] = 0; u.b[sizeof(lzo_uint) - 1] = 128;
+    u.a[0] = u.a[1] = 0;
+    u.b[sizeof(lzo_uint) - 1] = 128;
     p = u2p(&u, 0);
     r &= ((* (lzo_uintp) p) == 128);
 #endif
 #if (LZO_ABI_LITTLE_ENDIAN)
-    u.a[0] = u.a[1] = 0; u.b[0] = 128;
+    u.a[0] = u.a[1] = 0;
+    u.b[0] = 128;
     p = u2p(&u, 0);
     r &= ((* (lzo_uintp) p) == 128);
 #endif
     u.a[0] = u.a[1] = 0;
-    u.b[0] = 1; u.b[3] = 2;
+    u.b[0] = 1;
+    u.b[3] = 2;
     p = u2p(&u, 1);
     r &= UA_GET_NE16(p) == 0;
     r &= UA_GET_LE16(p) == 0;
@@ -127,13 +131,16 @@ _lzo_config_check(void)
     r &= UA_GET_NE16(p) == LZO_UINT16_C(0x8180);
 #endif
     u.a[0] = u.a[1] = 0;
-    u.b[0] = 3; u.b[5] = 4;
+    u.b[0] = 3;
+    u.b[5] = 4;
     p = u2p(&u, 1);
     r &= UA_GET_NE32(p) == 0;
     r &= UA_GET_LE32(p) == 0;
     u.b[1] = 128;
     r &= UA_GET_LE32(p) == 128;
-    u.b[2] = 129; u.b[3] = 130; u.b[4] = 131;
+    u.b[2] = 129;
+    u.b[3] = 130;
+    u.b[4] = 131;
     r &= UA_GET_LE32(p) == LZO_UINT32_C(0x83828180);
 #if (LZO_ABI_BIG_ENDIAN)
     r &= UA_GET_NE32(p) == LZO_UINT32_C(0x80818283);
@@ -143,7 +150,8 @@ _lzo_config_check(void)
 #endif
 #if defined(UA_GET_NE64)
     u.c[0] = u.c[1] = 0;
-    u.b[0] = 5; u.b[9] = 6;
+    u.b[0] = 5;
+    u.b[9] = 6;
     p = u2p(&u, 1);
     u.c[0] = u.c[1] = 0;
     r &= UA_GET_NE64(p) == 0;
@@ -154,32 +162,52 @@ _lzo_config_check(void)
 #endif
 #endif
 #if defined(lzo_bitops_ctlz32)
-    { unsigned i = 0; lzo_uint32_t v;
-    for (v = 1; v != 0 && r == 1; v <<= 1, i++) {
+    {
+        unsigned i = 0;
+        lzo_uint32_t v;
+
+        for (v = 1; v != 0 && r == 1; v <<= 1, i++)
+        {
             r &= lzo_bitops_ctlz32(v) == 31 - i;
             r &= lzo_bitops_ctlz32_func(v) == 31 - i;
-    }}
+        }
+    }
 #endif
 #if defined(lzo_bitops_ctlz64)
-    { unsigned i = 0; lzo_uint64_t v;
-    for (v = 1; v != 0 && r == 1; v <<= 1, i++) {
+    {
+        unsigned i = 0;
+        lzo_uint64_t v;
+
+        for (v = 1; v != 0 && r == 1; v <<= 1, i++)
+        {
             r &= lzo_bitops_ctlz64(v) == 63 - i;
             r &= lzo_bitops_ctlz64_func(v) == 63 - i;
-    }}
+        }
+    }
 #endif
 #if defined(lzo_bitops_cttz32)
-    { unsigned i = 0; lzo_uint32_t v;
-    for (v = 1; v != 0 && r == 1; v <<= 1, i++) {
+    {
+        unsigned i = 0;
+        lzo_uint32_t v;
+
+        for (v = 1; v != 0 && r == 1; v <<= 1, i++)
+        {
             r &= lzo_bitops_cttz32(v) == i;
             r &= lzo_bitops_cttz32_func(v) == i;
-    }}
+        }
+    }
 #endif
 #if defined(lzo_bitops_cttz64)
-    { unsigned i = 0; lzo_uint64_t v;
-    for (v = 1; v != 0 && r == 1; v <<= 1, i++) {
+    {
+        unsigned i = 0;
+        lzo_uint64_t v;
+
+        for (v = 1; v != 0 && r == 1; v <<= 1, i++)
+        {
             r &= lzo_bitops_cttz64(v) == i;
             r &= lzo_bitops_cttz64_func(v) == i;
-    }}
+        }
+    }
 #endif
 #endif
     LZO_UNUSED_FUNC(lzo_bitops_unused_funcs);
@@ -217,13 +245,15 @@ __lzo_init_v2(unsigned v, int s1, int s2, int s3, int s4, int s5,
         (s4 == -1 || s4 == (int) sizeof(lzo_uint32_t)) &&
         (s5 == -1 || s5 == (int) sizeof(lzo_uint)) &&
         (s6 == -1 || s6 == (int) lzo_sizeof_dict_t) &&
-        (s7 == -1 || s7 == (int) sizeof(char *)) &&
+        (s7 == -1 || s7 == (int) sizeof(char*)) &&
         (s8 == -1 || s8 == (int) sizeof(lzo_voidp)) &&
         (s9 == -1 || s9 == (int) sizeof(lzo_callback_t));
+
     if (!r)
         return LZO_E_ERROR;
 
     r = _lzo_config_check();
+
     if (r != LZO_E_OK)
         return r;
 

extern/lzo/src/lzo_mchw.ch

@@ -110,9 +110,9 @@ LZO_COMPRESS_T;
 ************************************************************************/
 
 static int
-init_match ( LZO_COMPRESS_T *c, lzo_swd_p s,
+init_match(LZO_COMPRESS_T* c, lzo_swd_p s,
            const lzo_bytep dict, lzo_uint dict_len,
-             lzo_uint32_t flags )
+           lzo_uint32_t flags)
 {
     int r;
 
@@ -127,7 +127,8 @@ init_match ( LZO_COMPRESS_T *c, lzo_swd_p s,
     c->lit_bytes = c->match_bytes = c->rep_bytes = 0;
     c->lazy = 0;
 
-    r = swd_init(s,dict,dict_len);
+    r = swd_init(s, dict, dict_len);
+
     if (r != LZO_E_OK)
     {
         swd_exit(s);
@@ -144,8 +145,8 @@ init_match ( LZO_COMPRESS_T *c, lzo_swd_p s,
 ************************************************************************/
 
 static int
-find_match ( LZO_COMPRESS_T *c, lzo_swd_p s,
-             lzo_uint this_len, lzo_uint skip )
+find_match(LZO_COMPRESS_T* c, lzo_swd_p s,
+           lzo_uint this_len, lzo_uint skip)
 {
     assert(c->init);
 
@@ -164,8 +165,10 @@ find_match ( LZO_COMPRESS_T *c, lzo_swd_p s,
     s->m_len = SWD_THRESHOLD;
     s->m_off = 0;
 #ifdef SWD_BEST_OFF
+
     if (s->use_best_off)
-        lzo_memset(s->best_pos,0,sizeof(s->best_pos));
+        lzo_memset(s->best_pos, 0, sizeof(s->best_pos));
+
 #endif
     swd_findbest(s);
     c->m_len = s->m_len;
@@ -183,9 +186,11 @@ find_match ( LZO_COMPRESS_T *c, lzo_swd_p s,
     {
         c->look = s->look + 1;
     }
+
     c->bp = c->ip - c->look;
 
 #if 0
+
     /* brute force match search */
     if (c->m_len > SWD_THRESHOLD && c->m_len + 1 <= c->look)
     {
@@ -195,18 +200,23 @@ find_match ( LZO_COMPRESS_T *c, lzo_swd_p s,
 
         if (ip - in > s->swd_n)
             in = ip - s->swd_n;
+
         for (;;)
         {
             while (*in != *ip)
                 in++;
+
             if (in == ip)
                 break;
+
             if (in != m)
-                if (lzo_memcmp(in,ip,c->m_len+1) == 0)
-                    printf("%p %p %p %5d\n",in,ip,m,c->m_len);
+                if (lzo_memcmp(in, ip, c->m_len + 1) == 0)
+                    printf("%p %p %p %5d\n", in, ip, m, c->m_len);
+
             in++;
         }
     }
+
 #endif
 
     if (c->cb && c->cb->nprogress && c->textsize > c->printcount)

extern/lzo/src/lzo_ptr.c

@@ -61,14 +61,19 @@ __lzo_align_gap(const lzo_voidp ptr, lzo_uint size)
 #error "__LZO_UINTPTR_T_IS_POINTER is unsupported"
 #else
     lzo_uintptr_t p, n;
+
     if (size < 2) return 0;
+
     p = __lzo_ptr_linear(ptr);
 #if 0
     n = (((p + size - 1) / size) * size) - p;
 #else
+
     if ((size & (size - 1)) != 0)
         return 0;
-    n = size; n = ((p + n - 1) & ~(n - 1)) - p;
+
+    n = size;
+    n = ((p + n - 1) & ~(n - 1)) - p;
 #endif
 #endif
     assert((long)n >= 0);

extern/lzo/src/lzo_ptr.h

@@ -98,12 +98,12 @@ typedef union
     size_t          a_size_t;
     ptrdiff_t       a_ptrdiff_t;
     lzo_uintptr_t   a_lzo_uintptr_t;
-    void *          a_void_p;
-    char *          a_char_p;
-    unsigned char * a_uchar_p;
-    const void *          a_c_void_p;
-    const char *          a_c_char_p;
-    const unsigned char * a_c_uchar_p;
+    void*           a_void_p;
+    char*           a_char_p;
+    unsigned char* a_uchar_p;
+    const void*           a_c_void_p;
+    const char*           a_c_char_p;
+    const unsigned char* a_c_uchar_p;
     lzo_voidp       a_lzo_voidp;
     lzo_bytep       a_lzo_bytep;
     const lzo_voidp a_c_lzo_voidp;

extern/lzo/src/lzo_swd.ch

@@ -43,10 +43,10 @@
 
 /* unsigned type for dictionary access - don't waste memory here */
 #if (0UL + SWD_N + SWD_F + SWD_F < 65535UL)
-   typedef lzo_uint16_t     swd_uint;
+typedef lzo_uint16_t     swd_uint;
 #  define SWD_UINT_MAX      0xffffu
 #else
-   typedef lzo_uint32_t     swd_uint;
+typedef lzo_uint32_t     swd_uint;
 #  define SWD_UINT_MAX      0xffffffffu
 #endif
 #define swd_uintp           swd_uint *
@@ -85,18 +85,18 @@
 
 typedef struct
 {
-/* public - "built-in" */
+    /* public - "built-in" */
     lzo_uint swd_n;
     lzo_uint swd_f;
     lzo_uint swd_threshold;
 
-/* public - configuration */
+    /* public - configuration */
     lzo_uint max_chain;
     lzo_uint nice_length;
     lzo_bool use_best_off;
     lzo_uint lazy_insert;
 
-/* public - output */
+    /* public - output */
     lzo_uint m_len;
     lzo_uint m_off;
     lzo_uint look;
@@ -105,19 +105,19 @@ typedef struct
     lzo_uint best_off[ SWD_BEST_OFF ];
 #endif
 
-/* semi public */
-    LZO_COMPRESS_T *c;
+    /* semi public */
+    LZO_COMPRESS_T* c;
     lzo_uint m_pos;
 #if defined(SWD_BEST_OFF)
     lzo_uint best_pos[ SWD_BEST_OFF ];
 #endif
 
-/* private */
+    /* private */
     const lzo_bytep dict;
     const lzo_bytep dict_end;
     lzo_uint dict_len;
 
-/* private */
+    /* private */
     lzo_uint ip;                /* input pointer (lookahead) */
     lzo_uint bp;                /* buffer pointer */
     lzo_uint rp;                /* remove pointer */
@@ -130,13 +130,13 @@ typedef struct
 
 #if defined(__LZO_CHECKER)
     /* malloc arrays of the exact size to detect any overrun */
-    unsigned char *b;
-    swd_uint *head3;
-    swd_uint *succ3;
-    swd_uint *best3;
-    swd_uint *llen3;
+    unsigned char* b;
+    swd_uint* head3;
+    swd_uint* succ3;
+    swd_uint* best3;
+    swd_uint* llen3;
 # ifdef HEAD2
-    swd_uint *head2;
+    swd_uint* head2;
 # endif
 
 #else
@@ -189,6 +189,7 @@ void swd_initdict(lzo_swd_p s, const lzo_bytep dict, lzo_uint dict_len)
 
     if (!dict || dict_len == 0)
         return;
+
     if (dict_len > s->swd_n)
     {
         dict += dict_len - s->swd_n;
@@ -198,7 +199,7 @@ void swd_initdict(lzo_swd_p s, const lzo_bytep dict, lzo_uint dict_len)
     s->dict = dict;
     s->dict_len = dict_len;
     s->dict_end = dict + dict_len;
-    lzo_memcpy(s_b(s),dict,dict_len);
+    lzo_memcpy(s_b(s), dict, dict_len);
     s->ip = dict_len;
 }
 
@@ -213,16 +214,17 @@ void swd_insertdict(lzo_swd_p s, lzo_uint node, lzo_uint len)
 
     if (len) do
         {
-        key = HEAD3(s_b(s),node);
-        s_succ3(s)[node] = s_get_head3(s,key);
+            key = HEAD3(s_b(s), node);
+            s_succ3(s)[node] = s_get_head3(s, key);
             s_head3(s)[key] = SWD_UINT(node);
             s_best3(s)[node] = SWD_UINT(s->swd_f + 1);
             s_llen3(s)[key]++;
             assert(s_llen3(s)[key] <= s->swd_n);
 
 #ifdef HEAD2
-        IF_HEAD2(s) {
-            key = HEAD2(s_b(s),node);
+            IF_HEAD2(s)
+            {
+                key = HEAD2(s_b(s), node);
                 s_head2(s)[key] = SWD_UINT(node);
             }
 #endif
@@ -255,15 +257,19 @@ int swd_init(lzo_swd_p s, const lzo_bytep dict, lzo_uint dict_len)
     r &= s->best3 != NULL;
     r &= s->llen3 != NULL;
 #ifdef HEAD2
-    IF_HEAD2(s) {
+    IF_HEAD2(s)
+    {
         s->head2 = (swd_uintp) malloc(sizeof(swd_uint) * 65536L);
         r &= s->head2 != NULL;
     }
 #endif
-    if (r != 1) {
+
+    if (r != 1)
+    {
         swd_exit(s);
         return LZO_E_OUT_OF_MEMORY;
     }
+
 #endif
 
     s->m_len = 0;
@@ -271,6 +277,7 @@ int swd_init(lzo_swd_p s, const lzo_bytep dict, lzo_uint dict_len)
 #if defined(SWD_BEST_OFF)
     {
         unsigned i;
+
         for (i = 0; i < SWD_BEST_OFF; i++)
             s->best_off[i] = s->best_pos[i] = 0;
     }
@@ -288,8 +295,10 @@ int swd_init(lzo_swd_p s, const lzo_bytep dict, lzo_uint dict_len)
 
     s->b_size = s->swd_n + s->swd_f;
 #if 0
+
     if (2 * s->swd_f >= s->swd_n || s->b_size + s->swd_f >= SWD_UINT_MAX)
         return LZO_E_ERROR;
+
 #else
     LZO_COMPILE_TIME_ASSERT(!(0ul + 2 * SWD_F >= SWD_N))
     LZO_COMPILE_TIME_ASSERT(!(0ul + SWD_N + SWD_F + SWD_F >= SWD_UINT_MAX))
@@ -299,65 +308,80 @@ int swd_init(lzo_swd_p s, const lzo_bytep dict, lzo_uint dict_len)
 
     lzo_memset(s_llen3(s), 0, (lzo_uint)sizeof(s_llen3(s)[0]) * (lzo_uint)SWD_HSIZE);
 #ifdef HEAD2
-    IF_HEAD2(s) {
+    IF_HEAD2(s)
+    {
 #if 1
         lzo_memset(s_head2(s), 0xff, (lzo_uint)sizeof(s_head2(s)[0]) * 65536L);
         assert(s_head2(s)[0] == NIL2);
 #else
         lzo_xint i;
+
         for (i = 0; i < 65536L; i++)
             s_head2(s)[i] = NIL2;
+
 #endif
     }
 #endif
 
     s->ip = 0;
-    swd_initdict(s,dict,dict_len);
+    swd_initdict(s, dict, dict_len);
     s->bp = s->ip;
     s->first_rp = s->ip;
 
     assert(s->ip + s->swd_f <= s->b_size);
 #if 1
-    s->look = (lzo_uint) (s->c->in_end - s->c->ip);
+    s->look = (lzo_uint)(s->c->in_end - s->c->ip);
+
     if (s->look > 0)
     {
         if (s->look > s->swd_f)
             s->look = s->swd_f;
-        lzo_memcpy(&s_b(s)[s->ip],s->c->ip,s->look);
+
+        lzo_memcpy(&s_b(s)[s->ip], s->c->ip, s->look);
         s->c->ip += s->look;
         s->ip += s->look;
     }
+
 #else
     s->look = 0;
+
     while (s->look < s->swd_f)
     {
         int c;
+
         if ((c = getbyte(*(s->c))) < 0)
             break;
+
         s_b(s)[s->ip] = LZO_BYTE(c);
         s->ip++;
         s->look++;
     }
+
 #endif
+
     if (s->ip == s->b_size)
         s->ip = 0;
 
     if (s->look >= 2 && s->dict_len > 0)
-        swd_insertdict(s,0,s->dict_len);
+        swd_insertdict(s, 0, s->dict_len);
 
     s->rp = s->first_rp;
+
     if (s->rp >= s->node_count)
         s->rp -= s->node_count;
     else
         s->rp += s->b_size - s->node_count;
 
 #if 1 || defined(__LZO_CHECKER)
+
     /* initialize memory for the first few HEAD3 (if s->ip is not far
      * enough ahead to do this job for us). The value doesn't matter. */
-    if (s->look < 3) {
-        lzo_bytep p = &s_b(s)[s->bp+s->look];
+    if (s->look < 3)
+    {
+        lzo_bytep p = &s_b(s)[s->bp + s->look];
         p[0] = p[1] = p[2] = 0;
     }
+
 #endif
 
     return LZO_E_OK;
@@ -370,13 +394,19 @@ void swd_exit(lzo_swd_p s)
 #if defined(__LZO_CHECKER)
     /* free in reverse order of allocations */
 #ifdef HEAD2
-    free(s->head2); s->head2 = NULL;
+    free(s->head2);
+    s->head2 = NULL;
 #endif
-    free(s->llen3); s->llen3 = NULL;
-    free(s->best3); s->best3 = NULL;
-    free(s->succ3); s->succ3 = NULL;
-    free(s->head3); s->head3 = NULL;
-    free(s->b); s->b = NULL;
+    free(s->llen3);
+    s->llen3 = NULL;
+    free(s->best3);
+    s->best3 = NULL;
+    free(s->succ3);
+    s->succ3 = NULL;
+    free(s->head3);
+    s->head3 = NULL;
+    free(s->b);
+    s->b = NULL;
 #else
     LZO_UNUSED(s);
 #endif
@@ -400,23 +430,30 @@ void swd_getbyte(lzo_swd_p s)
     {
         if (s->look > 0)
             --s->look;
+
 #if 1 || defined(__LZO_CHECKER)
         /* initialize memory - value doesn't matter */
         s_b(s)[s->ip] = 0;
+
         if (s->ip < s->swd_f)
             s->b_wrap[s->ip] = 0;
+
 #endif
     }
     else
     {
         s_b(s)[s->ip] = LZO_BYTE(c);
+
         if (s->ip < s->swd_f)
             s->b_wrap[s->ip] = LZO_BYTE(c);
     }
+
     if (++s->ip == s->b_size)
         s->ip = 0;
+
     if (++s->bp == s->b_size)
         s->bp = 0;
+
     if (++s->rp == s->b_size)
         s->rp = 0;
 }
@@ -434,6 +471,7 @@ void swd_remove_node(lzo_swd_p s, lzo_uint node)
         lzo_uint key;
 
 #ifdef LZO_DEBUG
+
         if (s->first_rp != LZO_UINT_MAX)
         {
             if (node != s->first_rp)
@@ -441,19 +479,23 @@ void swd_remove_node(lzo_swd_p s, lzo_uint node)
                        (long)node, (long)s->rp, (long)s->ip, (long)s->bp,
                        (long)s->first_rp, (long)(s->ip - node),
                        (long)(s->ip - s->bp));
+
             assert(node == s->first_rp);
             s->first_rp = LZO_UINT_MAX;
         }
+
 #endif
 
-        key = HEAD3(s_b(s),node);
+        key = HEAD3(s_b(s), node);
         assert(s_llen3(s)[key] > 0);
         --s_llen3(s)[key];
 
 #ifdef HEAD2
-        IF_HEAD2(s) {
-            key = HEAD2(s_b(s),node);
+        IF_HEAD2(s)
+        {
+            key = HEAD2(s_b(s), node);
             assert(s_head2(s)[key] != NIL2);
+
             if ((lzo_uint) s_head2(s)[key] == node)
                 s_head2(s)[key] = NIL2;
         }
@@ -477,11 +519,11 @@ void swd_accept(lzo_swd_p s, lzo_uint n)
         {
             lzo_uint key;
 
-        swd_remove_node(s,s->rp);
+            swd_remove_node(s, s->rp);
 
             /* add bp into HEAD3 */
-        key = HEAD3(s_b(s),s->bp);
-        s_succ3(s)[s->bp] = s_get_head3(s,key);
+            key = HEAD3(s_b(s), s->bp);
+            s_succ3(s)[s->bp] = s_get_head3(s, key);
             s_head3(s)[key] = SWD_UINT(s->bp);
             s_best3(s)[s->bp] = SWD_UINT(s->swd_f + 1);
             s_llen3(s)[key]++;
@@ -489,14 +531,16 @@ void swd_accept(lzo_swd_p s, lzo_uint n)
 
 #ifdef HEAD2
             /* add bp into HEAD2 */
-        IF_HEAD2(s) {
-            key = HEAD2(s_b(s),s->bp);
+            IF_HEAD2(s)
+            {
+                key = HEAD2(s_b(s), s->bp);
                 s_head2(s)[key] = SWD_UINT(s->bp);
             }
 #endif
 
             swd_getbyte(s);
-    } while (--n != 0);
+        }
+        while (--n != 0);
 }
 
 
@@ -519,7 +563,8 @@ void swd_search(lzo_swd_p s, lzo_uint node, lzo_uint cnt)
     assert(s->m_len > 0);
 
     scan_end1 = bp[m_len - 1];
-    for ( ; cnt-- > 0; node = s_succ3(s)[node])
+
+    for (; cnt-- > 0; node = s_succ3(s)[node])
     {
         p1 = bp;
         p2 = b + node;
@@ -536,45 +581,62 @@ void swd_search(lzo_swd_p s, lzo_uint node, lzo_uint cnt)
             p2[1] == p1[1])
         {
             lzo_uint i;
-            assert(lzo_memcmp(bp,&b[node],3) == 0);
+            assert(lzo_memcmp(bp, &b[node], 3) == 0);
 
 #if 0 && (LZO_OPT_UNALIGNED32)
-            p1 += 3; p2 += 3;
+            p1 += 3;
+            p2 += 3;
+
             while (p1 + 4 <= px && UA_GET_NE32(p1) == UA_GET_NE32(p2))
                 p1 += 4, p2 += 4;
+
             while (p1 < px && *p1 == *p2)
                 p1 += 1, p2 += 1;
+
 #else
-            p1 += 2; p2 += 2;
-            do {} while (++p1 < px && *p1 == *++p2);
+            p1 += 2;
+            p2 += 2;
+
+            do {}
+            while (++p1 < px && *p1 == *++p2);
+
 #endif
             i = pd(p1, bp);
 
 #ifdef LZO_DEBUG
-            if (lzo_memcmp(bp,&b[node],i) != 0)
+
+            if (lzo_memcmp(bp, &b[node], i) != 0)
                 printf("%5ld %5ld %5ld %02x/%02x %02x/%02x\n",
                        (long)s->bp, (long) node, (long) i,
-                        bp[0], bp[1], b[node], b[node+1]);
+                       bp[0], bp[1], b[node], b[node + 1]);
+
 #endif
-            assert(lzo_memcmp(bp,&b[node],i) == 0);
+            assert(lzo_memcmp(bp, &b[node], i) == 0);
 
 #if defined(SWD_BEST_OFF)
+
             if (i < SWD_BEST_OFF)
             {
                 if (s->best_pos[i] == 0)
                     s->best_pos[i] = node + 1;
             }
+
 #endif
+
             if (i > m_len)
             {
                 s->m_len = m_len = i;
                 s->m_pos = node;
+
                 if (m_len == s->look)
                     return;
+
                 if (m_len >= s->nice_length)
                     return;
+
                 if (m_len > (lzo_uint) s_best3(s)[node])
                     return;
+
                 scan_end1 = bp[m_len - 1];
             }
         }
@@ -596,18 +658,24 @@ lzo_bool swd_search2(lzo_swd_p s)
     assert(s->look >= 2);
     assert(s->m_len > 0);
 
-    key = s_head2(s)[ HEAD2(s_b(s),s->bp) ];
+    key = s_head2(s)[ HEAD2(s_b(s), s->bp) ];
+
     if (key == NIL2)
         return 0;
+
 #ifdef LZO_DEBUG
-    if (lzo_memcmp(&s_b(s)[s->bp],&s_b(s)[key],2) != 0)
+
+    if (lzo_memcmp(&s_b(s)[s->bp], &s_b(s)[key], 2) != 0)
         printf("%5ld %5ld %02x/%02x %02x/%02x\n", (long)s->bp, (long)key,
-                s_b(s)[s->bp], s_b(s)[s->bp+1], s_b(s)[key], s_b(s)[key+1]);
+               s_b(s)[s->bp], s_b(s)[s->bp + 1], s_b(s)[key], s_b(s)[key + 1]);
+
 #endif
-    assert(lzo_memcmp(&s_b(s)[s->bp],&s_b(s)[key],2) == 0);
+    assert(lzo_memcmp(&s_b(s)[s->bp], &s_b(s)[key], 2) == 0);
 #if defined(SWD_BEST_OFF)
+
     if (s->best_pos[2] == 0)
         s->best_pos[2] = key + 1;
+
 #endif
 
     if (s->m_len < 2)
@@ -615,6 +683,7 @@ lzo_bool swd_search2(lzo_swd_p s)
         s->m_len = 2;
         s->m_pos = key;
     }
+
     return 1;
 }
 
@@ -635,55 +704,69 @@ void swd_findbest(lzo_swd_p s)
     assert(s->m_len > 0);
 
     /* get current head, add bp into HEAD3 */
-    key = HEAD3(s_b(s),s->bp);
-    node = s_succ3(s)[s->bp] = s_get_head3(s,key);
+    key = HEAD3(s_b(s), s->bp);
+    node = s_succ3(s)[s->bp] = s_get_head3(s, key);
     cnt = s_llen3(s)[key]++;
     assert(s_llen3(s)[key] <= s->swd_n + s->swd_f);
+
     if (cnt > s->max_chain && s->max_chain > 0)
         cnt = s->max_chain;
+
     s_head3(s)[key] = SWD_UINT(s->bp);
 
     s->b_char = s_b(s)[s->bp];
     len = s->m_len;
+
     if (s->m_len >= s->look)
     {
         if (s->look == 0)
             s->b_char = -1;
+
         s->m_off = 0;
         s_best3(s)[s->bp] = SWD_UINT(s->swd_f + 1);
     }
     else
     {
 #if defined(HEAD2)
+
         if (swd_search2(s) && s->look >= 3)
-            swd_search(s,node,cnt);
+            swd_search(s, node, cnt);
+
 #else
+
         if (s->look >= 3)
-            swd_search(s,node,cnt);
+            swd_search(s, node, cnt);
+
 #endif
+
         if (s->m_len > len)
-            s->m_off = swd_pos2off(s,s->m_pos);
+            s->m_off = swd_pos2off(s, s->m_pos);
+
         s_best3(s)[s->bp] = SWD_UINT(s->m_len);
 
 #if defined(SWD_BEST_OFF)
+
         if (s->use_best_off)
         {
             unsigned i;
+
             for (i = 2; i < SWD_BEST_OFF; i++)
                 if (s->best_pos[i] > 0)
-                    s->best_off[i] = swd_pos2off(s,s->best_pos[i]-1);
+                    s->best_off[i] = swd_pos2off(s, s->best_pos[i] - 1);
                 else
                     s->best_off[i] = 0;
         }
+
 #endif
     }
 
-    swd_remove_node(s,s->rp);
+    swd_remove_node(s, s->rp);
 
 #ifdef HEAD2
     /* add bp into HEAD2 */
-    IF_HEAD2(s) {
-        key = HEAD2(s_b(s),s->bp);
+    IF_HEAD2(s)
+    {
+        key = HEAD2(s_b(s), s->bp);
         s_head2(s)[key] = SWD_UINT(s->bp);
     }
 #endif

extern/lzo/src/lzo_util.c

@@ -66,13 +66,13 @@ lzo_version(void)
     return LZO_VERSION;
 }
 
-LZO_PUBLIC(const char *)
+LZO_PUBLIC(const char*)
 lzo_version_string(void)
 {
     return lzo_version_string_;
 }
 
-LZO_PUBLIC(const char *)
+LZO_PUBLIC(const char*)
 lzo_version_date(void)
 {
     return lzo_version_date_;
@@ -121,20 +121,26 @@ lzo_adler32(lzo_uint32_t adler, const lzo_bytep buf, lzo_uint len)
     {
         k = len < LZO_NMAX ? (unsigned) len : LZO_NMAX;
         len -= k;
+
         if (k >= 16) do
             {
-            LZO_DO16(buf,0);
+                LZO_DO16(buf, 0);
                 buf += 16;
                 k -= 16;
-        } while (k >= 16);
+            }
+            while (k >= 16);
+
         if (k != 0) do
             {
                 s1 += *buf++;
                 s2 += s1;
-        } while (--k > 0);
+            }
+            while (--k > 0);
+
         s1 %= LZO_BASE;
         s2 %= LZO_BASE;
     }
+
     return (s2 << 16) | s1;
 }
 

extern/lzo/src/stats1a.h

@@ -57,17 +57,18 @@ extern "C" {
 //
 ************************************************************************/
 
-typedef struct {
+typedef struct
+{
 
-/* configuration */
+    /* configuration */
     unsigned rbits;
     unsigned clevel;
 
-/* internal configuration */
+    /* internal configuration */
     unsigned dbits;
     unsigned lbits;
 
-/* constants */
+    /* constants */
     unsigned min_match_short;
     unsigned max_match_short;
     unsigned min_match_long;
@@ -78,7 +79,7 @@ typedef struct {
     unsigned r0fast;
     unsigned r0max;
 
-/* counts */
+    /* counts */
     long short_matches;
     long long_matches;
     long r1_matches;
@@ -88,14 +89,14 @@ typedef struct {
     long r0fast_runs;
     long r0long_runs;
 
-/* */
+    /* */
     long lit_run[RSIZE];
     long lit_run_after_long_match[RSIZE];
     long short_match[MAX_MATCH_SHORT + 1];
     long long_match[MAX_MATCH_LONG + 1];
     long marker[256];
 
-/* these could prove useful for further optimizations */
+    /* these could prove useful for further optimizations */
     long short_match_offset_osize[MAX_MATCH_SHORT + 1];
     long short_match_offset_256[MAX_MATCH_SHORT + 1];
     long short_match_offset_1024[MAX_MATCH_SHORT + 1];
@@ -104,13 +105,13 @@ typedef struct {
     long matches_out_of_range_4;
     long match_out_of_range[MAX_MATCH_SHORT + 1];
 
-/* */
+    /* */
     long in_len;
     long out_len;
 }
 lzo1a_stats_t;
 
-extern lzo1a_stats_t *lzo1a_stats;
+extern lzo1a_stats_t* lzo1a_stats;
 
 
 

extern/lzo/src/stats1b.h

@@ -57,19 +57,19 @@ extern "C" {
 
 typedef struct
 {
-/* algorithm configuration */
+    /* algorithm configuration */
     unsigned r_bits;
     unsigned m3o_bits;
     unsigned dd_bits;
     unsigned clevel;
 
-/* internal configuration */
+    /* internal configuration */
     unsigned d_bits;
     long min_lookahead;
     long max_lookbehind;
-    const char *compress_id;
+    const char* compress_id;
 
-/* counts */
+    /* counts */
     long lit_runs;
     long r0short_runs;
     long r0fast_runs;
@@ -80,16 +80,16 @@ typedef struct
     long m4_matches;
     long r1_matches;
 
-/* */
+    /* */
     long lit_run[R0MIN];
     long m2_match[M2_MAX_LEN + 1];
     long m3_match[M3_MAX_LEN + 1];
 #if (M3O_BITS < 8)
     long lit_runs_after_m3_match;
-    long lit_run_after_m3_match[LZO_SIZE(8-M3O_BITS)];
+    long lit_run_after_m3_match[LZO_SIZE(8 - M3O_BITS)];
 #endif
 
-/* */
+    /* */
     long matches;
     long match_bytes;
     long literals;
@@ -97,21 +97,21 @@ typedef struct
     long literal_bytes;
     double literal_overhead_percent;
 
-/* */
+    /* */
     long unused_dict_entries;
     double unused_dict_entries_percent;
 
-/* */
+    /* */
     long in_len;
     long out_len;
 }
 lzo1b_stats_t;
 
 
-void _lzo1b_stats_init(lzo1b_stats_t *lzo_stats);
-void _lzo1b_stats_calc(lzo1b_stats_t *lzo_stats);
+void _lzo1b_stats_init(lzo1b_stats_t* lzo_stats);
+void _lzo1b_stats_calc(lzo1b_stats_t* lzo_stats);
 
-extern lzo1b_stats_t * const lzo1b_stats;
+extern lzo1b_stats_t* const lzo1b_stats;
 
 #define lzo_stats_t     lzo1b_stats_t
 #define lzo_stats       lzo1b_stats

extern/zlib/CMakeLists.txt

@@ -0,0 +1,34 @@
+if(NOT WIN32)
+find_package(ZLIB)
+endif()
+if(WIN32 OR NOT ZLIB_FOUND)
+message("-- Using Athena's built-in zlib")
+add_library(z
+    adler32.c
+    compress.c
+    crc32.c
+    deflate.c
+    infback.c
+    inffast.c
+    inflate.c
+    inftrees.c
+    trees.c
+    uncompr.c
+    zutil.c
+    crc32.h
+    deflate.h
+    gzguts.h
+    inffast.h
+    inffixed.h
+    inflate.h
+    inftrees.h
+    trees.h
+    zconf.h
+    zlib.h
+    zutil.h)
+if(WIN32 AND NOT UNIX)
+install(FILES zconf.h zlib.h DESTINATION include COMPONENT zlib)
+install(TARGETS z DESTINATION lib COMPONENT zlib)
+endif()
+set(ZLIB_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR} CACHE PATH "Zlib include path" FORCE)
+endif()

extern/zlib/adler32.c

@@ -63,12 +63,12 @@ local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
 
 /* ========================================================================= */
 #ifdef WIN32
-uLong ZEXPORT adler32(uLong adler, const Bytef *buf, uInt len)
+uLong ZEXPORT adler32(uLong adler, const Bytef* buf, uInt len)
 #else
 uLong ZEXPORT adler32(adler, buf, len)
-    uLong adler;
-    const Bytef *buf;
-    uInt len;
+uLong adler;
+const Bytef* buf;
+uInt len;
 #endif
 {
     unsigned long sum2;
@@ -79,13 +79,18 @@ uLong ZEXPORT adler32(adler, buf, len)
     adler &= 0xffff;
 
     /* in case user likes doing a byte at a time, keep it fast */
-    if (len == 1) {
+    if (len == 1)
+    {
         adler += buf[0];
+
         if (adler >= BASE)
             adler -= BASE;
+
         sum2 += adler;
+
         if (sum2 >= BASE)
             sum2 -= BASE;
+
         return adler | (sum2 << 16);
     }
 
@@ -94,40 +99,54 @@ uLong ZEXPORT adler32(adler, buf, len)
         return 1L;
 
     /* in case short lengths are provided, keep it somewhat fast */
-    if (len < 16) {
-        while (len--) {
+    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) {
+    while (len >= NMAX)
+    {
         len -= NMAX;
         n = NMAX / 16;          /* NMAX is divisible by 16 */
-        do {
+
+        do
+        {
             DO16(buf);          /* 16 sums unrolled */
             buf += 16;
-        } while (--n);
+        }
+        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) {
+    if (len)                    /* avoid modulos if none remaining */
+    {
+        while (len >= 16)
+        {
             len -= 16;
             DO16(buf);
             buf += 16;
         }
-        while (len--) {
+
+        while (len--)
+        {
             adler += *buf++;
             sum2 += adler;
         }
+
         MOD(adler);
         MOD(sum2);
     }
@@ -141,9 +160,9 @@ uLong ZEXPORT adler32(adler, buf, len)
 local uLong adler32_combine_(uLong adler1, uLong adler2, z_off64_t len2)
 #else
 local uLong adler32_combine_(adler1, adler2, len2)
-    uLong adler1;
-    uLong adler2;
-    z_off64_t len2;
+uLong adler1;
+uLong adler2;
+z_off64_t len2;
 #endif
 {
     unsigned long sum1;
@@ -162,10 +181,15 @@ local uLong adler32_combine_(adler1, adler2, len2)
     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 >= (BASE << 1)) sum2 -= (BASE << 1);
+
     if (sum2 >= BASE) sum2 -= BASE;
+
     return sum1 | (sum2 << 16);
 }
 
@@ -174,9 +198,9 @@ local uLong adler32_combine_(adler1, adler2, len2)
 uLong ZEXPORT adler32_combine(uLong adler1, uLong adler2, z_off_t len2)
 #else
 uLong ZEXPORT adler32_combine(adler1, adler2, len2)
-    uLong adler1;
-    uLong adler2;
-    z_off_t len2;
+uLong adler1;
+uLong adler2;
+z_off_t len2;
 #endif
 {
     return adler32_combine_(adler1, adler2, len2);
@@ -186,9 +210,9 @@ uLong ZEXPORT adler32_combine(adler1, adler2, len2)
 uLong ZEXPORT adler32_combine64(uLong adler1, uLong adler2, z_off64_t len2)
 #else
 uLong ZEXPORT adler32_combine64(adler1, adler2, len2)
-    uLong adler1;
-    uLong adler2;
-    z_off64_t len2;
+uLong adler1;
+uLong adler2;
+z_off64_t len2;
 #endif
 {
     return adler32_combine_(adler1, adler2, len2);

extern/zlib/compress.c

@@ -20,14 +20,14 @@
    Z_STREAM_ERROR if the level parameter is invalid.
 */
 #ifdef WIN32
-int ZEXPORT compress2 (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen, int level)
+int ZEXPORT compress2(Bytef* dest, uLongf* destLen, const Bytef* source, uLong sourceLen, int level)
 #else
-int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
-    Bytef *dest;
-    uLongf *destLen;
-    const Bytef *source;
-    uLong sourceLen;
-    int level;
+int ZEXPORT compress2(dest, destLen, source, sourceLen, level)
+Bytef* dest;
+uLongf* destLen;
+const Bytef* source;
+uLong sourceLen;
+int level;
 #endif
 {
     z_stream stream;
@@ -36,11 +36,14 @@ int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
     stream.next_in = (Bytef*)source;
     stream.avail_in = (uInt)sourceLen;
 #ifdef MAXSEG_64K
+
     /* Check for source > 64K on 16-bit machine: */
     if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
+
 #endif
     stream.next_out = dest;
-    stream.avail_out = (uInt)*destLen;
+    stream.avail_out = (uInt) * destLen;
+
     if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
 
     stream.zalloc = (alloc_func)0;
@@ -48,13 +51,17 @@ int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
     stream.opaque = (voidpf)0;
 
     err = deflateInit(&stream, level);
+
     if (err != Z_OK) return err;
 
     err = deflate(&stream, Z_FINISH);
-    if (err != Z_STREAM_END) {
+
+    if (err != Z_STREAM_END)
+    {
         deflateEnd(&stream);
         return err == Z_OK ? Z_BUF_ERROR : err;
     }
+
     *destLen = stream.total_out;
 
     err = deflateEnd(&stream);
@@ -64,13 +71,13 @@ int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
 /* ===========================================================================
  */
 #ifdef WIN32
-int ZEXPORT compress(Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen)
+int ZEXPORT compress(Bytef* dest, uLongf* destLen, const Bytef* source, uLong sourceLen)
 #else
-int ZEXPORT compress (dest, destLen, source, sourceLen)
-    Bytef *dest;
-    uLongf *destLen;
-    const Bytef *source;
-    uLong sourceLen;
+int ZEXPORT compress(dest, destLen, source, sourceLen)
+Bytef* dest;
+uLongf* destLen;
+const Bytef* source;
+uLong sourceLen;
 #endif
 {
     return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
@@ -81,10 +88,10 @@ int ZEXPORT compress (dest, destLen, source, sourceLen)
    this function needs to be updated.
  */
 #ifdef WIN32
-uLong ZEXPORT compressBound (uLong sourceLen)
+uLong ZEXPORT compressBound(uLong sourceLen)
 #else
-uLong ZEXPORT compressBound (sourceLen)
-    uLong sourceLen;
+uLong ZEXPORT compressBound(sourceLen)
+uLong sourceLen;
 #endif
 {
     return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +

extern/zlib/crc32.c

@@ -37,19 +37,19 @@
 #  define BYFOUR
 #endif
 #ifdef BYFOUR
-   local unsigned long crc32_little OF((unsigned long,
-                        const unsigned char FAR *, unsigned));
-   local unsigned long crc32_big OF((unsigned long,
-                        const unsigned char FAR *, unsigned));
+local unsigned long crc32_little OF((unsigned long,
+                                     const unsigned char FAR*, unsigned));
+local unsigned long crc32_big OF((unsigned long,
+                                  const unsigned char FAR*, unsigned));
 #  define TBLS 8
 #else
 #  define TBLS 1
 #endif /* BYFOUR */
 
 /* Local functions for crc concatenation */
-local unsigned long gf2_matrix_times OF((unsigned long *mat,
+local unsigned long gf2_matrix_times OF((unsigned long* mat,
                                         unsigned long vec));
-local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
+local void gf2_matrix_square OF((unsigned long* square, unsigned long* mat));
 local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2));
 
 
@@ -59,7 +59,7 @@ local volatile int crc_table_empty = 1;
 local z_crc_t FAR crc_table[TBLS][256];
 local void make_crc_table OF((void));
 #ifdef MAKECRCH
-   local void write_table OF((FILE *, const z_crc_t FAR *));
+local void write_table OF((FILE*, const z_crc_t FAR*));
 #endif /* MAKECRCH */
 /*
   Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
@@ -94,44 +94,55 @@ local void make_crc_table()
     z_crc_t poly;                       /* polynomial exclusive-or pattern */
     /* terms of polynomial defining this crc (except x^32): */
     static volatile int first = 1;      /* flag to limit concurrent making */
-    static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
+    static const unsigned char p[] = {0, 1, 2, 4, 5, 7, 8, 10, 11, 12, 16, 22, 23, 26};
 
     /* See if another task is already doing this (not thread-safe, but better
        than nothing -- significantly reduces duration of vulnerability in
        case the advice about DYNAMIC_CRC_TABLE is ignored) */
-    if (first) {
+    if (first)
+    {
         first = 0;
 
         /* make exclusive-or pattern from polynomial (0xedb88320UL) */
         poly = 0;
-        for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++)
+
+        for (n = 0; n < (int)(sizeof(p) / sizeof(unsigned char)); n++)
             poly |= (z_crc_t)1 << (31 - p[n]);
 
         /* generate a crc for every 8-bit value */
-        for (n = 0; n < 256; n++) {
+        for (n = 0; n < 256; n++)
+        {
             c = (z_crc_t)n;
+
             for (k = 0; k < 8; k++)
                 c = c & 1 ? poly ^ (c >> 1) : c >> 1;
+
             crc_table[0][n] = c;
         }
 
 #ifdef BYFOUR
+
         /* generate crc for each value followed by one, two, and three zeros,
            and then the byte reversal of those as well as the first table */
-        for (n = 0; n < 256; n++) {
+        for (n = 0; n < 256; n++)
+        {
             c = crc_table[0][n];
             crc_table[4][n] = ZSWAP32(c);
-            for (k = 1; k < 4; k++) {
+
+            for (k = 1; k < 4; k++)
+            {
                 c = crc_table[0][c & 0xff] ^ (c >> 8);
                 crc_table[k][n] = c;
                 crc_table[k + 4][n] = ZSWAP32(c);
             }
         }
+
 #endif /* BYFOUR */
 
         crc_table_empty = 0;
     }
-    else {      /* not first */
+    else        /* not first */
+    {
         /* wait for the other guy to finish (not efficient, but rare) */
         while (crc_table_empty)
             ;
@@ -140,10 +151,12 @@ local void make_crc_table()
 #ifdef MAKECRCH
     /* write out CRC tables to crc32.h */
     {
-        FILE *out;
+        FILE* out;
 
         out = fopen("crc32.h", "w");
+
         if (out == NULL) return;
+
         fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");
         fprintf(out, " * Generated automatically by crc32.c\n */\n\n");
         fprintf(out, "local const z_crc_t FAR ");
@@ -151,10 +164,13 @@ local void make_crc_table()
         write_table(out, crc_table[0]);
 #  ifdef BYFOUR
         fprintf(out, "#ifdef BYFOUR\n");
-        for (k = 1; k < 8; k++) {
+
+        for (k = 1; k < 8; k++)
+        {
             fprintf(out, "  },\n  {\n");
             write_table(out, crc_table[k]);
         }
+
         fprintf(out, "#endif\n");
 #  endif /* BYFOUR */
         fprintf(out, "  }\n};\n");
@@ -165,8 +181,8 @@ local void make_crc_table()
 
 #ifdef MAKECRCH
 local void write_table(out, table)
-    FILE *out;
-    const z_crc_t FAR *table;
+FILE* out;
+const z_crc_t FAR* table;
 {
     int n;
 
@@ -187,13 +203,15 @@ local void write_table(out, table)
 /* =========================================================================
  * This function can be used by asm versions of crc32()
  */
-const z_crc_t FAR * ZEXPORT get_crc_table()
+const z_crc_t FAR* ZEXPORT get_crc_table()
 {
 #ifdef DYNAMIC_CRC_TABLE
+
     if (crc_table_empty)
         make_crc_table();
+
 #endif /* DYNAMIC_CRC_TABLE */
-    return (const z_crc_t FAR *)crc_table;
+    return (const z_crc_t FAR*)crc_table;
 }
 
 /* ========================================================================= */
@@ -202,45 +220,59 @@ const z_crc_t FAR * ZEXPORT get_crc_table()
 
 /* ========================================================================= */
 #ifdef WIN32
-unsigned long ZEXPORT crc32(unsigned long crc, const unsigned char FAR *buf, uInt len)
+unsigned long ZEXPORT crc32(unsigned long crc, const unsigned char FAR* buf, uInt len)
 #else
 unsigned long ZEXPORT crc32(crc, buf, len)
-    unsigned long crc;
-    const unsigned char FAR *buf;
-    uInt len;
+unsigned long crc;
+const unsigned char FAR* buf;
+uInt len;
 #endif
 {
     if (buf == Z_NULL) return 0UL;
 
 #ifdef DYNAMIC_CRC_TABLE
+
     if (crc_table_empty)
         make_crc_table();
+
 #endif /* DYNAMIC_CRC_TABLE */
 
 #ifdef BYFOUR
 #ifdef WIN32
-    int size_match = (sizeof(void *) == sizeof(ptrdiff_t));
-    if (size_match) {
+    int size_match = (sizeof(void*) == sizeof(ptrdiff_t));
+
+    if (size_match)
+    {
 #else
-    if (sizeof(void *) == sizeof(ptrdiff_t)) {
+
+    if (sizeof(void*) == sizeof(ptrdiff_t))
+    {
 #endif /* WIN32 */
         z_crc_t endian;
 
         endian = 1;
-       if (*((unsigned char *)(&endian)))
+
+        if (*((unsigned char*)(&endian)))
             return crc32_little(crc, buf, len);
         else
             return crc32_big(crc, buf, len);
     }
+
 #endif /* BYFOUR */
     crc = crc ^ 0xffffffffUL;
-    while (len >= 8) {
+
+    while (len >= 8)
+    {
         DO8;
         len -= 8;
     }
-    if (len) do {
+
+    if (len) do
+        {
             DO1;
-    } while (--len);
+        }
+        while (--len);
+
     return crc ^ 0xffffffffUL;
 }
 
@@ -254,38 +286,48 @@ unsigned long ZEXPORT crc32(crc, buf, len)
 
 /* ========================================================================= */
 #ifdef WIN32
-local unsigned long crc32_little(unsigned long crc, const unsigned char FAR *buf, unsigned len)
+local unsigned long crc32_little(unsigned long crc, const unsigned char FAR* buf, unsigned len)
 #else
 local unsigned long crc32_little(crc, buf, len)
-    unsigned long crc;
-    const unsigned char FAR *buf;
-    unsigned len;
+unsigned long crc;
+const unsigned char FAR* buf;
+unsigned len;
 #endif
 {
     register z_crc_t c;
-    register const z_crc_t FAR *buf4;
+    register const z_crc_t FAR* buf4;
 
     c = (z_crc_t)crc;
     c = ~c;
-    while (len && ((ptrdiff_t)buf & 3)) {
+
+    while (len && ((ptrdiff_t)buf & 3))
+    {
         c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
         len--;
     }
 
-    buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
-    while (len >= 32) {
+    buf4 = (const z_crc_t FAR*)(const void FAR*)buf;
+
+    while (len >= 32)
+    {
         DOLIT32;
         len -= 32;
     }
-    while (len >= 4) {
+
+    while (len >= 4)
+    {
         DOLIT4;
         len -= 4;
     }
-    buf = (const unsigned char FAR *)buf4;
 
-    if (len) do {
+    buf = (const unsigned char FAR*)buf4;
+
+    if (len) do
+        {
             c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
-    } while (--len);
+        }
+        while (--len);
+
     c = ~c;
     return (unsigned long)c;
 }
@@ -298,40 +340,50 @@ local unsigned long crc32_little(crc, buf, len)
 
 /* ========================================================================= */
 #ifdef WIN32
-local unsigned long crc32_big(unsigned long crc, const unsigned char FAR *buf, unsigned len)
+local unsigned long crc32_big(unsigned long crc, const unsigned char FAR* buf, unsigned len)
 #else
 local unsigned long crc32_big(crc, buf, len)
-    unsigned long crc;
-    const unsigned char FAR *buf;
-    unsigned len;
+unsigned long crc;
+const unsigned char FAR* buf;
+unsigned len;
 #endif
 {
     register z_crc_t c;
-    register const z_crc_t FAR *buf4;
+    register const z_crc_t FAR* buf4;
 
     c = ZSWAP32((z_crc_t)crc);
     c = ~c;
-    while (len && ((ptrdiff_t)buf & 3)) {
+
+    while (len && ((ptrdiff_t)buf & 3))
+    {
         c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
         len--;
     }
 
-    buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
+    buf4 = (const z_crc_t FAR*)(const void FAR*)buf;
     buf4--;
-    while (len >= 32) {
+
+    while (len >= 32)
+    {
         DOBIG32;
         len -= 32;
     }
-    while (len >= 4) {
+
+    while (len >= 4)
+    {
         DOBIG4;
         len -= 4;
     }
-    buf4++;
-    buf = (const unsigned char FAR *)buf4;
 
-    if (len) do {
+    buf4++;
+    buf = (const unsigned char FAR*)buf4;
+
+    if (len) do
+        {
             c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
-    } while (--len);
+        }
+        while (--len);
+
     c = ~c;
     return (unsigned long)(ZSWAP32(c));
 }
@@ -342,32 +394,36 @@ local unsigned long crc32_big(crc, buf, len)
 
 /* ========================================================================= */
 #ifdef WIN32
-local unsigned long gf2_matrix_times(unsigned long *mat, unsigned long vec)
+local unsigned long gf2_matrix_times(unsigned long* mat, unsigned long vec)
 #else
 local unsigned long gf2_matrix_times(mat, vec)
-    unsigned long *mat;
-    unsigned long vec;
+unsigned long* mat;
+unsigned long vec;
 #endif
 {
     unsigned long sum;
 
     sum = 0;
-    while (vec) {
+
+    while (vec)
+    {
         if (vec & 1)
             sum ^= *mat;
+
         vec >>= 1;
         mat++;
     }
+
     return sum;
 }
 
 /* ========================================================================= */
 #ifdef WIN32
-local void gf2_matrix_square(unsigned long *square, unsigned long *mat)
+local void gf2_matrix_square(unsigned long* square, unsigned long* mat)
 #else
 local void gf2_matrix_square(square, mat)
-    unsigned long *square;
-    unsigned long *mat;
+unsigned long* square;
+unsigned long* mat;
 #endif
 {
     int n;
@@ -381,9 +437,9 @@ local void gf2_matrix_square(square, mat)
 local uLong crc32_combine_(uLong crc1, uLong crc2, z_off64_t len2)
 #else
 local uLong crc32_combine_(crc1, crc2, len2)
-    uLong crc1;
-    uLong crc2;
-    z_off64_t len2;
+uLong crc1;
+uLong crc2;
+z_off64_t len2;
 #endif
 {
     int n;
@@ -398,7 +454,9 @@ local uLong crc32_combine_(crc1, crc2, len2)
     /* put operator for one zero bit in odd */
     odd[0] = 0xedb88320UL;          /* CRC-32 polynomial */
     row = 1;
-    for (n = 1; n < GF2_DIM; n++) {
+
+    for (n = 1; n < GF2_DIM; n++)
+    {
         odd[n] = row;
         row <<= 1;
     }
@@ -411,11 +469,14 @@ local uLong crc32_combine_(crc1, crc2, len2)
 
     /* apply len2 zeros to crc1 (first square will put the operator for one
        zero byte, eight zero bits, in even) */
-    do {
+    do
+    {
         /* apply zeros operator for this bit of len2 */
         gf2_matrix_square(even, odd);
+
         if (len2 & 1)
             crc1 = gf2_matrix_times(even, crc1);
+
         len2 >>= 1;
 
         /* if no more bits set, then done */
@@ -424,12 +485,15 @@ local uLong crc32_combine_(crc1, crc2, len2)
 
         /* another iteration of the loop with odd and even swapped */
         gf2_matrix_square(odd, even);
+
         if (len2 & 1)
             crc1 = gf2_matrix_times(odd, crc1);
+
         len2 >>= 1;
 
         /* if no more bits set, then done */
-    } while (len2 != 0);
+    }
+    while (len2 != 0);
 
     /* return combined crc */
     crc1 ^= crc2;
@@ -441,9 +505,9 @@ local uLong crc32_combine_(crc1, crc2, len2)
 uLong ZEXPORT crc32_combine(uLong crc1, uLong crc2, z_off_t len2)
 #else
 uLong ZEXPORT crc32_combine(crc1, crc2, len2)
-    uLong crc1;
-    uLong crc2;
-    z_off_t len2;
+uLong crc1;
+uLong crc2;
+z_off_t len2;
 #endif
 {
     return crc32_combine_(crc1, crc2, len2);
@@ -453,9 +517,9 @@ uLong ZEXPORT crc32_combine(crc1, crc2, len2)
 uLong ZEXPORT crc32_combine64(uLong crc1, uLong crc2, z_off64_t len2)
 #else
 uLong ZEXPORT crc32_combine64(crc1, crc2, len2)
-    uLong crc1;
-    uLong crc2;
-    z_off64_t len2;
+uLong crc1;
+uLong crc2;
+z_off64_t len2;
 #endif
 {
     return crc32_combine_(crc1, crc2, len2);

extern/zlib/deflate.h

@@ -62,12 +62,15 @@
 
 
 /* Data structure describing a single value and its code string. */
-typedef struct ct_data_s {
-    union {
+typedef struct ct_data_s
+{
+    union
+    {
         ush  freq;       /* frequency count */
         ush  code;       /* bit string */
     } fc;
-    union {
+    union
+    {
         ush  dad;        /* father node in Huffman tree */
         ush  len;        /* length of bit string */
     } dl;
@@ -80,10 +83,11 @@ typedef struct ct_data_s {
 
 typedef struct static_tree_desc_s  static_tree_desc;
 
-typedef struct tree_desc_s {
-    ct_data *dyn_tree;           /* the dynamic tree */
+typedef struct tree_desc_s
+{
+    ct_data* dyn_tree;           /* the dynamic tree */
     int     max_code;            /* largest code with non zero frequency */
-    static_tree_desc *stat_desc; /* the corresponding static tree */
+    static_tree_desc* stat_desc; /* the corresponding static tree */
 } FAR tree_desc;
 
 typedef ush Pos;
@@ -94,12 +98,13 @@ typedef unsigned IPos;
  * save space in the various tables. IPos is used only for parameter passing.
  */
 
-typedef struct internal_state {
+typedef struct internal_state
+{
     z_streamp strm;      /* pointer back to this zlib stream */
     int   status;        /* as the name implies */
-    Bytef *pending_buf;  /* output still pending */
+    Bytef* pending_buf;  /* output still pending */
     ulg   pending_buf_size; /* size of pending_buf */
-    Bytef *pending_out;  /* next pending byte to output to the stream */
+    Bytef* pending_out;  /* next pending byte to output to the stream */
     uInt   pending;      /* nb of bytes in the pending buffer */
     int   wrap;          /* bit 0 true for zlib, bit 1 true for gzip */
     gz_headerp  gzhead;  /* gzip header information to write */
@@ -113,7 +118,7 @@ typedef struct internal_state {
     uInt  w_bits;        /* log2(w_size)  (8..16) */
     uInt  w_mask;        /* w_size - 1 */
 
-    Bytef *window;
+    Bytef* window;
     /* Sliding window. Input bytes are read into the second half of the window,
      * and move to the first half later to keep a dictionary of at least wSize
      * bytes. With this organization, matches are limited to a distance of
@@ -128,13 +133,13 @@ typedef struct internal_state {
      * is directly used as sliding window.
      */
 
-    Posf *prev;
+    Posf* prev;
     /* Link to older string with same hash index. To limit the size of this
      * array to 64K, this link is maintained only for the last 32K strings.
      * An index in this array is thus a window index modulo 32K.
      */
 
-    Posf *head; /* Heads of the hash chains or NIL. */
+    Posf* head; /* Heads of the hash chains or NIL. */
 
     uInt  ins_h;          /* hash index of string to be inserted */
     uInt  hash_size;      /* number of elements in hash table */
@@ -193,28 +198,28 @@ typedef struct internal_state {
     /* used by trees.c: */
     /* Didn't use ct_data typedef below to suppress compiler warning */
     struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */
-    struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
-    struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */
+    struct ct_data_s dyn_dtree[2 * D_CODES + 1]; /* distance tree */
+    struct ct_data_s bl_tree[2 * BL_CODES + 1]; /* Huffman tree for bit lengths */
 
     struct tree_desc_s l_desc;               /* desc. for literal tree */
     struct tree_desc_s d_desc;               /* desc. for distance tree */
     struct tree_desc_s bl_desc;              /* desc. for bit length tree */
 
-    ush bl_count[MAX_BITS+1];
+    ush bl_count[MAX_BITS + 1];
     /* number of codes at each bit length for an optimal tree */
 
-    int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */
+    int heap[2 * L_CODES + 1];  /* heap used to build the Huffman trees */
     int heap_len;               /* number of elements in the heap */
     int heap_max;               /* element of largest frequency */
     /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
      * The same heap array is used to build all trees.
      */
 
-    uch depth[2*L_CODES+1];
+    uch depth[2 * L_CODES + 1];
     /* Depth of each subtree used as tie breaker for trees of equal frequency
      */
 
-    uchf *l_buf;          /* buffer for literals or lengths */
+    uchf* l_buf;          /* buffer for literals or lengths */
 
     uInt  lit_bufsize;
     /* Size of match buffer for literals/lengths.  There are 4 reasons for
@@ -238,7 +243,7 @@ typedef struct internal_state {
 
     uInt last_lit;      /* running index in l_buf */
 
-    ushf *d_buf;
+    ushf* d_buf;
     /* Buffer for distances. To simplify the code, d_buf and l_buf have
      * the same number of elements. To use different lengths, an extra flag
      * array would be necessary.
@@ -292,14 +297,14 @@ typedef struct internal_state {
 /* Number of bytes after end of data in window to initialize in order to avoid
    memory checker errors from longest match routines */
 
-        /* in trees.c */
-void ZLIB_INTERNAL _tr_init OF((deflate_state *s));
-int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc));
-void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf,
+/* in trees.c */
+void ZLIB_INTERNAL _tr_init OF((deflate_state* s));
+int ZLIB_INTERNAL _tr_tally OF((deflate_state* s, unsigned dist, unsigned lc));
+void ZLIB_INTERNAL _tr_flush_block OF((deflate_state* s, charf* buf,
                                        ulg stored_len, int last));
-void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s));
-void ZLIB_INTERNAL _tr_align OF((deflate_state *s));
-void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
+void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state* s));
+void ZLIB_INTERNAL _tr_align OF((deflate_state* s));
+void ZLIB_INTERNAL _tr_stored_block OF((deflate_state* s, charf* buf,
                                         ulg stored_len, int last));
 
 #define d_code(dist) \
@@ -313,11 +318,11 @@ void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
 /* Inline versions of _tr_tally for speed: */
 
 #if defined(GEN_TREES_H) || !defined(STDC)
-  extern uch ZLIB_INTERNAL _length_code[];
-  extern uch ZLIB_INTERNAL _dist_code[];
+extern uch ZLIB_INTERNAL _length_code[];
+extern uch ZLIB_INTERNAL _dist_code[];
 #else
-  extern const uch ZLIB_INTERNAL _length_code[];
-  extern const uch ZLIB_INTERNAL _dist_code[];
+extern const uch ZLIB_INTERNAL _length_code[];
+extern const uch ZLIB_INTERNAL _dist_code[];
 #endif
 
 # define _tr_tally_lit(s, c, flush) \

extern/zlib/gzclose.c

@@ -12,7 +12,7 @@
 int ZEXPORT gzclose(gzFile file)
 #else
 int ZEXPORT gzclose(file)
-    gzFile file;
+gzFile file;
 #endif
 {
 #ifndef NO_GZCOMPRESS
@@ -20,6 +20,7 @@ int ZEXPORT gzclose(file)
 
     if (file == NULL)
         return Z_STREAM_ERROR;
+
     state = (gz_statep)file;
 
     return state->mode == GZ_READ ? gzclose_r(file) : gzclose_w(file);

extern/zlib/gzguts.h

@@ -100,8 +100,8 @@
 
 /* gz* functions always use library allocation functions */
 #ifndef STDC
-  extern voidp  malloc OF((uInt size));
-  extern void   free   OF((voidpf ptr));
+extern voidp  malloc OF((uInt size));
+extern void   free   OF((voidpf ptr));
 #endif
 
 /* get errno and strerror definition */
@@ -119,10 +119,10 @@
 
 /* provide prototypes for these when building zlib without LFS */
 #if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0
-    ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
-    ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
-    ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
-    ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
+ZEXTERN gzFile ZEXPORT gzopen64 OF((const char*, const char*));
+ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
+ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
+ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
 #endif
 
 /* default memLevel */
@@ -147,7 +147,8 @@
 #define GZIP 2      /* decompress a gzip stream */
 
 /* internal gzip file state data structure */
-typedef struct {
+typedef struct
+{
     /* exposed contents for gzgetc() macro */
     struct gzFile_s x;      /* "x" for exposed */
     /* x.have: number of bytes available at x.next */
@@ -156,11 +157,11 @@ typedef struct {
     /* used for both reading and writing */
     int mode;               /* see gzip modes above */
     int fd;                 /* file descriptor */
-    char *path;             /* path or fd for error messages */
+    char* path;             /* path or fd for error messages */
     unsigned size;          /* buffer size, zero if not allocated yet */
     unsigned want;          /* requested buffer size, default is GZBUFSIZE */
-    unsigned char *in;      /* input buffer */
-    unsigned char *out;     /* output buffer (double-sized when reading) */
+    unsigned char* in;      /* input buffer */
+    unsigned char* out;     /* output buffer (double-sized when reading) */
     int direct;             /* 0 if processing gzip, 1 if transparent */
     /* just for reading */
     int how;                /* 0: get header, 1: copy, 2: decompress */
@@ -175,16 +176,16 @@ typedef struct {
     int seek;               /* true if seek request pending */
     /* error information */
     int err;                /* error code */
-    char *msg;              /* error message */
+    char* msg;              /* error message */
     /* zlib inflate or deflate stream */
     z_stream strm;          /* stream structure in-place (not a pointer) */
 } gz_state;
-typedef gz_state FAR *gz_statep;
+typedef gz_state FAR* gz_statep;
 
 /* shared functions */
-void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *));
+void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char*));
 #if defined UNDER_CE
-char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error));
+char ZLIB_INTERNAL* gz_strwinerror OF((DWORD error));
 #endif
 
 /* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t

extern/zlib/gzlib.c

@@ -17,7 +17,7 @@
 
 /* Local functions */
 local void gz_reset OF((gz_statep));
-local gzFile gz_open OF((const void *, int, const char *));
+local gzFile gz_open OF((const void*, int, const char*));
 
 #if defined UNDER_CE
 
@@ -30,12 +30,12 @@ local gzFile gz_open OF((const void *, int, const char *));
 
    The gz_strwinerror function does not change the current setting of
    GetLastError. */
-char ZLIB_INTERNAL *gz_strwinerror (error)
-     DWORD error;
+char ZLIB_INTERNAL* gz_strwinerror(error)
+DWORD error;
 {
     static char buf[1024];
 
-    wchar_t *msgbuf;
+    wchar_t* msgbuf;
     DWORD lasterr = GetLastError();
     DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM
                                 | FORMAT_MESSAGE_ALLOCATE_BUFFER,
@@ -45,23 +45,28 @@ char ZLIB_INTERNAL *gz_strwinerror (error)
                                 (LPVOID)&msgbuf,
                                 0,
                                 NULL);
-    if (chars != 0) {
+
+    if (chars != 0)
+    {
         /* If there is an \r\n appended, zap it.  */
         if (chars >= 2
-            && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') {
+                && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n')
+        {
             chars -= 2;
             msgbuf[chars] = 0;
         }
 
-        if (chars > sizeof (buf) - 1) {
-            chars = sizeof (buf) - 1;
+        if (chars > sizeof(buf) - 1)
+        {
+            chars = sizeof(buf) - 1;
             msgbuf[chars] = 0;
         }
 
         wcstombs(buf, msgbuf, chars + 1);
         LocalFree(msgbuf);
     }
-    else {
+    else
+    {
         sprintf(buf, "unknown win32 error (%ld)", error);
     }
 
@@ -76,15 +81,18 @@ char ZLIB_INTERNAL *gz_strwinerror (error)
 local void gz_reset(gz_statep state)
 #else
 local void gz_reset(state)
-    gz_statep state;
+gz_statep state;
 #endif
 {
     state->x.have = 0;              /* no output data available */
-    if (state->mode == GZ_READ) {   /* for reading ... */
+
+    if (state->mode == GZ_READ)     /* for reading ... */
+    {
         state->eof = 0;             /* not at end of file */
         state->past = 0;            /* have not read past end yet */
         state->how = LOOK;          /* look for gzip header */
     }
+
     state->seek = 0;                /* no seek request pending */
     gz_error(state, Z_OK, NULL);    /* clear error */
     state->x.pos = 0;               /* no uncompressed data yet */
@@ -93,12 +101,12 @@ local void gz_reset(state)
 
 /* Open a gzip file either by name or file descriptor. */
 #ifdef WIN32
-local gzFile gz_open(const void *path, int fd, const char *mode)
+local gzFile gz_open(const void* path, int fd, const char* mode)
 #else
 local gzFile gz_open(path, fd, mode)
-    const void *path;
-    int fd;
-    const char *mode;
+const void* path;
+int fd;
+const char* mode;
 #endif
 {
     gz_statep state;
@@ -117,8 +125,10 @@ local gzFile gz_open(path, fd, mode)
 
     /* allocate gzFile structure to return */
     state = malloc(sizeof(gz_state));
+
     if (state == NULL)
         return NULL;
+
     state->size = 0;            /* no buffers allocated yet */
     state->want = GZBUFSIZE;    /* requested buffer size */
     state->msg = NULL;          /* no error message yet */
@@ -128,87 +138,115 @@ local gzFile gz_open(path, fd, mode)
     state->level = Z_DEFAULT_COMPRESSION;
     state->strategy = Z_DEFAULT_STRATEGY;
     state->direct = 0;
-    while (*mode) {
+
+    while (*mode)
+    {
         if (*mode >= '0' && *mode <= '9')
             state->level = *mode - '0';
         else
-            switch (*mode) {
+            switch (*mode)
+            {
                 case 'r':
                     state->mode = GZ_READ;
                     break;
 #ifndef NO_GZCOMPRESS
+
                 case 'w':
                     state->mode = GZ_WRITE;
                     break;
+
                 case 'a':
                     state->mode = GZ_APPEND;
                     break;
 #endif
+
                 case '+':       /* can't read and write at the same time */
                     free(state);
                     return NULL;
+
                 case 'b':       /* ignore -- will request binary anyway */
                     break;
 #ifdef O_CLOEXEC
+
                 case 'e':
                     cloexec = 1;
                     break;
 #endif
 #ifdef O_EXCL
+
                 case 'x':
                     exclusive = 1;
                     break;
 #endif
+
                 case 'f':
                     state->strategy = Z_FILTERED;
                     break;
+
                 case 'h':
                     state->strategy = Z_HUFFMAN_ONLY;
                     break;
+
                 case 'R':
                     state->strategy = Z_RLE;
                     break;
+
                 case 'F':
                     state->strategy = Z_FIXED;
+
                 case 'T':
                     state->direct = 1;
+
                 default:        /* could consider as an error, but just ignore */
                     ;
             }
+
         mode++;
     }
 
     /* must provide an "r", "w", or "a" */
-    if (state->mode == GZ_NONE) {
+    if (state->mode == GZ_NONE)
+    {
         free(state);
         return NULL;
     }
 
     /* can't force transparent read */
-    if (state->mode == GZ_READ) {
-        if (state->direct) {
+    if (state->mode == GZ_READ)
+    {
+        if (state->direct)
+        {
             free(state);
             return NULL;
         }
+
         state->direct = 1;      /* for empty file */
     }
 
     /* save the path name for error messages */
 #ifdef _WIN32
-    if (fd == -2) {
+
+    if (fd == -2)
+    {
         len = wcstombs(NULL, path, 0);
-        if (len == (size_t)-1)
+
+        if (len == (size_t) - 1)
             len = 0;
     }
     else
 #endif
         len = strlen(path);
+
     state->path = malloc(len + 1);
-    if (state->path == NULL) {
+
+    if (state->path == NULL)
+    {
         free(state);
         return NULL;
     }
+
 #ifdef _WIN32
+
     if (fd == -2)
         if (len)
             wcstombs(state->path, path, len + 1);
@@ -245,17 +283,22 @@ local gzFile gz_open(path, fd, mode)
                     fd == -2 ? _wopen(path, oflag, 0666) :
 #endif
                     open(path, oflag, 0666));
-    if (state->fd == -1) {
+
+    if (state->fd == -1)
+    {
         free(state->path);
         free(state);
         return NULL;
     }
+
     if (state->mode == GZ_APPEND)
         state->mode = GZ_WRITE;         /* simplify later checks */
 
     /* save the current position for rewinding (only if reading) */
-    if (state->mode == GZ_READ) {
+    if (state->mode == GZ_READ)
+    {
         state->start = LSEEK(state->fd, 0, SEEK_CUR);
+
         if (state->start == -1) state->start = 0;
     }
 
@@ -268,11 +311,11 @@ local gzFile gz_open(path, fd, mode)
 
 /* -- see zlib.h -- */
 #ifdef WIN32
-gzFile ZEXPORT gzopen(const char *path, const char *mode)
+gzFile ZEXPORT gzopen(const char* path, const char* mode)
 #else
 gzFile ZEXPORT gzopen(path, mode)
-    const char *path;
-    const char *mode;
+const char* path;
+const char* mode;
 #endif
 {
     return gz_open(path, -1, mode);
@@ -280,11 +323,11 @@ gzFile ZEXPORT gzopen(path, mode)
 
 /* -- see zlib.h -- */
 #ifdef WIN32
-gzFile ZEXPORT gzopen64(const char *path, const char *mode)
+gzFile ZEXPORT gzopen64(const char* path, const char* mode)
 #else
 gzFile ZEXPORT gzopen64(path, mode)
-    const char *path;
-    const char *mode;
+const char* path;
+const char* mode;
 #endif
 {
     return gz_open(path, -1, mode);
@@ -292,18 +335,19 @@ gzFile ZEXPORT gzopen64(path, mode)
 
 /* -- see zlib.h -- */
 #ifdef WIN32
-gzFile ZEXPORT gzdopen(int fd, const char *mode)
+gzFile ZEXPORT gzdopen(int fd, const char* mode)
 #else
 gzFile ZEXPORT gzdopen(fd, mode)
-    int fd;
-    const char *mode;
+int fd;
+const char* mode;
 #endif
 {
-    char *path;         /* identifier for error messages */
+    char* path;         /* identifier for error messages */
     gzFile gz;
 
     if (fd == -1 || (path = malloc(7 + 3 * sizeof(int))) == NULL)
         return NULL;
+
     sprintf(path, "<fd:%d>", fd);   /* for debugging */
     gz = gz_open(path, fd, mode);
     free(path);
@@ -312,11 +356,11 @@ gzFile ZEXPORT gzdopen(fd, mode)
 
 /* -- see zlib.h -- */
 #ifdef _WIN32
-gzFile ZEXPORT gzopen_w(const wchar_t *path, const char *mode)
+gzFile ZEXPORT gzopen_w(const wchar_t* path, const char* mode)
 #else
 gzFile ZEXPORT gzopen_w(path, mode)
-    const wchar_t *path;
-    const char *mode;
+const wchar_t* path;
+const char* mode;
 #endif
 {
     return gz_open(path, -2, mode);
@@ -327,8 +371,8 @@ gzFile ZEXPORT gzopen_w(path, mode)
 int ZEXPORT gzbuffer(gzFile file, unsigned size)
 #else
 int ZEXPORT gzbuffer(file, size)
-    gzFile file;
-    unsigned size;
+gzFile file;
+unsigned size;
 #endif
 {
     gz_statep state;
@@ -336,7 +380,9 @@ int ZEXPORT gzbuffer(file, size)
     /* get internal structure and check integrity */
     if (file == NULL)
         return -1;
+
     state = (gz_statep)file;
+
     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
         return -1;
 
@@ -347,6 +393,7 @@ int ZEXPORT gzbuffer(file, size)
     /* check and set requested size */
     if (size < 2)
         size = 2;               /* need two bytes to check magic header */
+
     state->want = size;
     return 0;
 }
@@ -356,7 +403,7 @@ int ZEXPORT gzbuffer(file, size)
 int ZEXPORT gzrewind(gzFile file)
 #else
 int ZEXPORT gzrewind(file)
-    gzFile file;
+gzFile file;
 #endif
 {
     gz_statep state;
@@ -364,6 +411,7 @@ int ZEXPORT gzrewind(file)
     /* get internal structure */
     if (file == NULL)
         return -1;
+
     state = (gz_statep)file;
 
     /* check that we're reading and that there's no error */
@@ -374,6 +422,7 @@ int ZEXPORT gzrewind(file)
     /* back up and start over */
     if (LSEEK(state->fd, state->start, SEEK_SET) == -1)
         return -1;
+
     gz_reset(state);
     return 0;
 }
@@ -383,9 +432,9 @@ int ZEXPORT gzrewind(file)
 z_off64_t ZEXPORT gzseek64(gzFile file, z_off64_t offset, int whence)
 #else
 z_off64_t ZEXPORT gzseek64(file, offset, whence)
-    gzFile file;
-    z_off64_t offset;
-    int whence;
+gzFile file;
+z_off64_t offset;
+int whence;
 #endif
 {
     unsigned n;
@@ -395,7 +444,9 @@ z_off64_t ZEXPORT gzseek64(file, offset, whence)
     /* get internal structure and check integrity */
     if (file == NULL)
         return -1;
+
     state = (gz_statep)file;
+
     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
         return -1;
 
@@ -412,14 +463,18 @@ z_off64_t ZEXPORT gzseek64(file, offset, whence)
         offset -= state->x.pos;
     else if (state->seek)
         offset += state->skip;
+
     state->seek = 0;
 
     /* if within raw area while reading, just go there */
     if (state->mode == GZ_READ && state->how == COPY &&
-            state->x.pos + offset >= 0) {
+            state->x.pos + offset >= 0)
+    {
         ret = LSEEK(state->fd, offset - state->x.have, SEEK_CUR);
+
         if (ret == -1)
             return -1;
+
         state->x.have = 0;
         state->eof = 0;
         state->past = 0;
@@ -431,18 +486,23 @@ z_off64_t ZEXPORT gzseek64(file, offset, whence)
     }
 
     /* calculate skip amount, rewinding if needed for back seek when reading */
-    if (offset < 0) {
+    if (offset < 0)
+    {
         if (state->mode != GZ_READ)         /* writing -- can't go backwards */
             return -1;
+
         offset += state->x.pos;
+
         if (offset < 0)                     /* before start of file! */
             return -1;
+
         if (gzrewind(file) == -1)           /* rewind, then skip to offset */
             return -1;
     }
 
     /* if reading, skip what's in output buffer (one less gzgetc() check) */
-    if (state->mode == GZ_READ) {
+    if (state->mode == GZ_READ)
+    {
         n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > offset ?
             (unsigned)offset : state->x.have;
         state->x.have -= n;
@@ -452,10 +512,12 @@ z_off64_t ZEXPORT gzseek64(file, offset, whence)
     }
 
     /* request skip (if not zero) */
-    if (offset) {
+    if (offset)
+    {
         state->seek = 1;
         state->skip = offset;
     }
+
     return state->x.pos + offset;
 }
 
@@ -464,9 +526,9 @@ z_off64_t ZEXPORT gzseek64(file, offset, whence)
 z_off_t ZEXPORT gzseek(gzFile file, z_off_t offset, int whence)
 #else
 z_off_t ZEXPORT gzseek(file, offset, whence)
-    gzFile file;
-    z_off_t offset;
-    int whence;
+gzFile file;
+z_off_t offset;
+int whence;
 #endif
 {
     z_off64_t ret;
@@ -480,7 +542,7 @@ z_off_t ZEXPORT gzseek(file, offset, whence)
 z_off64_t ZEXPORT gztell64(gzFile file)
 #else
 z_off64_t ZEXPORT gztell64(file)
-    gzFile file;
+gzFile file;
 #endif
 {
     gz_statep state;
@@ -488,7 +550,9 @@ z_off64_t ZEXPORT gztell64(file)
     /* get internal structure and check integrity */
     if (file == NULL)
         return -1;
+
     state = (gz_statep)file;
+
     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
         return -1;
 
@@ -501,7 +565,7 @@ z_off64_t ZEXPORT gztell64(file)
 z_off_t ZEXPORT gztell(gzFile file)
 #else
 z_off_t ZEXPORT gztell(file)
-    gzFile file;
+gzFile file;
 #endif
 {
     z_off64_t ret;
@@ -515,7 +579,7 @@ z_off_t ZEXPORT gztell(file)
 z_off64_t ZEXPORT gzoffset64(gzFile file)
 #else
 z_off64_t ZEXPORT gzoffset64(file)
-    gzFile file;
+gzFile file;
 #endif
 {
     z_off64_t offset;
@@ -524,16 +588,21 @@ z_off64_t ZEXPORT gzoffset64(file)
     /* get internal structure and check integrity */
     if (file == NULL)
         return -1;
+
     state = (gz_statep)file;
+
     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
         return -1;
 
     /* compute and return effective offset in file */
     offset = LSEEK(state->fd, 0, SEEK_CUR);
+
     if (offset == -1)
         return -1;
+
     if (state->mode == GZ_READ)             /* reading */
         offset -= state->strm.avail_in;     /* don't count buffered input */
+
     return offset;
 }
 
@@ -542,7 +611,7 @@ z_off64_t ZEXPORT gzoffset64(file)
 z_off_t ZEXPORT gzoffset(gzFile file)
 #else
 z_off_t ZEXPORT gzoffset(file)
-    gzFile file;
+gzFile file;
 #endif
 {
     z_off64_t ret;
@@ -556,7 +625,7 @@ z_off_t ZEXPORT gzoffset(file)
 int ZEXPORT gzeof(gzFile file)
 #else
 int ZEXPORT gzeof(file)
-    gzFile file;
+gzFile file;
 #endif
 {
     gz_statep state;
@@ -564,7 +633,9 @@ int ZEXPORT gzeof(file)
     /* get internal structure and check integrity */
     if (file == NULL)
         return 0;
+
     state = (gz_statep)file;
+
     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
         return 0;
 
@@ -574,11 +645,11 @@ int ZEXPORT gzeof(file)
 
 /* -- see zlib.h -- */
 #ifdef WIN32
-const char * ZEXPORT gzerror(gzFile file, int *errnum)
+const char* ZEXPORT gzerror(gzFile file, int* errnum)
 #else
-const char * ZEXPORT gzerror(file, errnum)
-    gzFile file;
-    int *errnum;
+const char* ZEXPORT gzerror(file, errnum)
+gzFile file;
+int* errnum;
 #endif
 {
     gz_statep state;
@@ -586,13 +657,16 @@ const char * ZEXPORT gzerror(file, errnum)
     /* get internal structure and check integrity */
     if (file == NULL)
         return NULL;
+
     state = (gz_statep)file;
+
     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
         return NULL;
 
     /* return error information */
     if (errnum != NULL)
         *errnum = state->err;
+
     return state->msg == NULL ? "" : state->msg;
 }
 
@@ -601,7 +675,7 @@ const char * ZEXPORT gzerror(file, errnum)
 void ZEXPORT gzclearerr(gzFile file)
 #else
 void ZEXPORT gzclearerr(file)
-    gzFile file;
+gzFile file;
 #endif
 {
     gz_statep state;
@@ -609,15 +683,19 @@ void ZEXPORT gzclearerr(file)
     /* get internal structure and check integrity */
     if (file == NULL)
         return;
+
     state = (gz_statep)file;
+
     if (state->mode != GZ_READ && state->mode != GZ_WRITE)
         return;
 
     /* clear error and end-of-file */
-    if (state->mode == GZ_READ) {
+    if (state->mode == GZ_READ)
+    {
         state->eof = 0;
         state->past = 0;
     }
+
     gz_error(state, Z_OK, NULL);
 }
 
@@ -628,18 +706,20 @@ void ZEXPORT gzclearerr(file)
    allocation failure constructing the error message, then convert the error to
    out of memory. */
 #ifdef WIN32
-void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg)
+void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char* msg)
 #else
 void ZLIB_INTERNAL gz_error(state, err, msg)
-    gz_statep state;
-    int err;
-    const char *msg;
+gz_statep state;
+int err;
+const char* msg;
 #endif
 {
     /* free previously allocated message and clear */
-    if (state->msg != NULL) {
+    if (state->msg != NULL)
+    {
         if (state->err != Z_MEM_ERROR)
             free(state->msg);
+
         state->msg = NULL;
     }
 
@@ -649,21 +729,25 @@ void ZLIB_INTERNAL gz_error(state, err, msg)
 
     /* set error code, and if no message, then done */
     state->err = err;
+
     if (msg == NULL)
         return;
 
     /* for an out of memory error, save as static string */
-    if (err == Z_MEM_ERROR) {
-        state->msg = (char *)msg;
+    if (err == Z_MEM_ERROR)
+    {
+        state->msg = (char*)msg;
         return;
     }
 
     /* construct error message with path */
-    if ((state->msg = malloc(strlen(state->path) + strlen(msg) + 3)) == NULL) {
+    if ((state->msg = malloc(strlen(state->path) + strlen(msg) + 3)) == NULL)
+    {
         state->err = Z_MEM_ERROR;
-        state->msg = (char *)"out of memory";
+        state->msg = (char*)"out of memory";
         return;
     }
+
     strcpy(state->msg, state->path);
     strcat(state->msg, ": ");
     strcat(state->msg, msg);
@@ -680,11 +764,15 @@ unsigned ZLIB_INTERNAL gz_intmax()
     unsigned p, q;
 
     p = 1;
-    do {
+
+    do
+    {
         q = p;
         p <<= 1;
         p++;
-    } while (p > q);
+    }
+    while (p > q);
+
     return q >> 1;
 }
 #endif

extern/zlib/gzread.c

@@ -6,7 +6,7 @@
 #include "gzguts.h"
 
 /* Local functions */
-local int gz_load OF((gz_statep, unsigned char *, unsigned, unsigned *));
+local int gz_load OF((gz_statep, unsigned char*, unsigned, unsigned*));
 local int gz_avail OF((gz_statep));
 local int gz_look OF((gz_statep));
 local int gz_decomp OF((gz_statep));
@@ -18,30 +18,39 @@ local int gz_skip OF((gz_statep, z_off64_t));
    This function needs to loop on read(), since read() is not guaranteed to
    read the number of bytes requested, depending on the type of descriptor. */
 #ifdef WIN32
-local int gz_load(gz_statep state, unsigned char *buf, unsigned len, unsigned *have)
+local int gz_load(gz_statep state, unsigned char* buf, unsigned len, unsigned* have)
 #else
 local int gz_load(state, buf, len, have)
-    gz_statep state;
-    unsigned char *buf;
-    unsigned len;
-    unsigned *have;
+gz_statep state;
+unsigned char* buf;
+unsigned len;
+unsigned* have;
 #endif
 {
     int ret;
 
     *have = 0;
-    do {
+
+    do
+    {
         ret = read(state->fd, buf + *have, len - *have);
+
         if (ret <= 0)
             break;
+
         *have += ret;
-    } while (*have < len);
-    if (ret < 0) {
+    }
+    while (*have < len);
+
+    if (ret < 0)
+    {
         gz_error(state, Z_ERRNO, zstrerror());
         return -1;
     }
+
     if (ret == 0)
         state->eof = 1;
+
     return 0;
 }
 
@@ -56,7 +65,7 @@ local int gz_load(state, buf, len, have)
 local int gz_avail(gz_statep state)
 #else
 local int gz_avail(state)
-    gz_statep state;
+gz_statep state;
 #endif
 {
     unsigned got;
@@ -64,20 +73,29 @@ local int gz_avail(state)
 
     if (state->err != Z_OK && state->err != Z_BUF_ERROR)
         return -1;
-    if (state->eof == 0) {
-        if (strm->avail_in) {       /* copy what's there to the start */
-            unsigned char *p = state->in, *q = strm->next_in;
+
+    if (state->eof == 0)
+    {
+        if (strm->avail_in)         /* copy what's there to the start */
+        {
+            unsigned char* p = state->in, *q = strm->next_in;
             unsigned n = strm->avail_in;
-            do {
+
+            do
+            {
                 *p++ = *q++;
-            } while (--n);
             }
+            while (--n);
+        }
+
         if (gz_load(state, state->in + strm->avail_in,
                     state->size - strm->avail_in, &got) == -1)
             return -1;
+
         strm->avail_in += got;
         strm->next_in = state->in;
     }
+
     return 0;
 }
 
@@ -94,24 +112,30 @@ local int gz_avail(state)
 local int gz_look(gz_statep state)
 #else
 local int gz_look(state)
-    gz_statep state;
+gz_statep state;
 #endif
 {
     z_streamp strm = &(state->strm);
 
     /* allocate read buffers and inflate memory */
-    if (state->size == 0) {
+    if (state->size == 0)
+    {
         /* allocate buffers */
         state->in = malloc(state->want);
         state->out = malloc(state->want << 1);
-        if (state->in == NULL || state->out == NULL) {
+
+        if (state->in == NULL || state->out == NULL)
+        {
             if (state->out != NULL)
                 free(state->out);
+
             if (state->in != NULL)
                 free(state->in);
+
             gz_error(state, Z_MEM_ERROR, "out of memory");
             return -1;
         }
+
         state->size = state->want;
 
         /* allocate inflate memory */
@@ -120,7 +144,9 @@ local int gz_look(state)
         state->strm.opaque = Z_NULL;
         state->strm.avail_in = 0;
         state->strm.next_in = Z_NULL;
-        if (inflateInit2(&(state->strm), 15 + 16) != Z_OK) {    /* gunzip */
+
+        if (inflateInit2(&(state->strm), 15 + 16) != Z_OK)      /* gunzip */
+        {
             free(state->out);
             free(state->in);
             state->size = 0;
@@ -130,9 +156,11 @@ local int gz_look(state)
     }
 
     /* get at least the magic bytes in the input buffer */
-    if (strm->avail_in < 2) {
+    if (strm->avail_in < 2)
+    {
         if (gz_avail(state) == -1)
             return -1;
+
         if (strm->avail_in == 0)
             return 0;
     }
@@ -145,7 +173,8 @@ local int gz_look(state)
        the header will be written in a single operation, so that reading a
        single byte is sufficient indication that it is not a gzip file) */
     if (strm->avail_in > 1 &&
-            strm->next_in[0] == 31 && strm->next_in[1] == 139) {
+            strm->next_in[0] == 31 && strm->next_in[1] == 139)
+    {
         inflateReset(strm);
         state->how = GZIP;
         state->direct = 0;
@@ -154,7 +183,8 @@ local int gz_look(state)
 
     /* no gzip header -- if we were decoding gzip before, then this is trailing
        garbage.  Ignore the trailing garbage and finish. */
-    if (state->direct == 0) {
+    if (state->direct == 0)
+    {
         strm->avail_in = 0;
         state->eof = 1;
         state->x.have = 0;
@@ -165,11 +195,14 @@ local int gz_look(state)
        the output buffer is larger than the input buffer, which also assures
        space for gzungetc() */
     state->x.next = state->out;
-    if (strm->avail_in) {
+
+    if (strm->avail_in)
+    {
         memcpy(state->x.next, strm->next_in, strm->avail_in);
         state->x.have = strm->avail_in;
         strm->avail_in = 0;
     }
+
     state->how = COPY;
     state->direct = 1;
     return 0;
@@ -184,7 +217,7 @@ local int gz_look(state)
 local int gz_decomp(gz_statep state)
 #else
 local int gz_decomp(state)
-    gz_statep state;
+gz_statep state;
 #endif
 {
     int ret = Z_OK;
@@ -193,32 +226,43 @@ local int gz_decomp(state)
 
     /* fill output buffer up to end of deflate stream */
     had = strm->avail_out;
-    do {
+
+    do
+    {
         /* get more input for inflate() */
         if (strm->avail_in == 0 && gz_avail(state) == -1)
             return -1;
-        if (strm->avail_in == 0) {
+
+        if (strm->avail_in == 0)
+        {
             gz_error(state, Z_BUF_ERROR, "unexpected end of file");
             break;
         }
 
         /* decompress and handle errors */
         ret = inflate(strm, Z_NO_FLUSH);
-        if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) {
+
+        if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT)
+        {
             gz_error(state, Z_STREAM_ERROR,
                      "internal error: inflate stream corrupt");
             return -1;
         }
-        if (ret == Z_MEM_ERROR) {
+
+        if (ret == Z_MEM_ERROR)
+        {
             gz_error(state, Z_MEM_ERROR, "out of memory");
             return -1;
         }
-        if (ret == Z_DATA_ERROR) {              /* deflate stream invalid */
+
+        if (ret == Z_DATA_ERROR)                /* deflate stream invalid */
+        {
             gz_error(state, Z_DATA_ERROR,
                      strm->msg == NULL ? "compressed data error" : strm->msg);
             return -1;
         }
-    } while (strm->avail_out && ret != Z_STREAM_END);
+    }
+    while (strm->avail_out && ret != Z_STREAM_END);
 
     /* update available output */
     state->x.have = had - strm->avail_out;
@@ -242,32 +286,42 @@ local int gz_decomp(state)
 local int gz_fetch(gz_statep state)
 #else
 local int gz_fetch(state)
-    gz_statep state;
+gz_statep state;
 #endif
 {
     z_streamp strm = &(state->strm);
 
-    do {
-        switch(state->how) {
+    do
+    {
+        switch (state->how)
+        {
             case LOOK:      /* -> LOOK, COPY (only if never GZIP), or GZIP */
                 if (gz_look(state) == -1)
                     return -1;
+
                 if (state->how == LOOK)
                     return 0;
+
                 break;
+
             case COPY:      /* -> COPY */
                 if (gz_load(state, state->out, state->size << 1, &(state->x.have))
                         == -1)
                     return -1;
+
                 state->x.next = state->out;
                 return 0;
+
             case GZIP:      /* -> GZIP or LOOK (if end of gzip stream) */
                 strm->avail_out = state->size << 1;
                 strm->next_out = state->out;
+
                 if (gz_decomp(state) == -1)
                     return -1;
         }
-    } while (state->x.have == 0 && (!state->eof || strm->avail_in));
+    }
+    while (state->x.have == 0 && (!state->eof || strm->avail_in));
+
     return 0;
 }
 
@@ -276,16 +330,18 @@ local int gz_fetch(state)
 local int gz_skip(gz_statep state, z_off64_t len)
 #else
 local int gz_skip(state, len)
-    gz_statep state;
-    z_off64_t len;
+gz_statep state;
+z_off64_t len;
 #endif
 {
     unsigned n;
 
     /* skip over len bytes or reach end-of-file, whichever comes first */
     while (len)
+
         /* skip over whatever is in output buffer */
-        if (state->x.have) {
+        if (state->x.have)
+        {
             n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > len ?
                 (unsigned)len : state->x.have;
             state->x.have -= n;
@@ -299,11 +355,13 @@ local int gz_skip(state, len)
             break;
 
     /* need more data to skip -- load up output buffer */
-        else {
+        else
+        {
             /* get more output, looking for header if required */
             if (gz_fetch(state) == -1)
                 return -1;
         }
+
     return 0;
 }
 
@@ -312,9 +370,9 @@ local int gz_skip(state, len)
 int ZEXPORT gzread(gzFile file, voidp buf, unsigned len)
 #else
 int ZEXPORT gzread(file, buf, len)
-    gzFile file;
-    voidp buf;
-    unsigned len;
+gzFile file;
+voidp buf;
+unsigned len;
 #endif
 {
     unsigned got, n;
@@ -324,6 +382,7 @@ int ZEXPORT gzread(file, buf, len)
     /* get internal structure */
     if (file == NULL)
         return -1;
+
     state = (gz_statep)file;
     strm = &(state->strm);
 
@@ -334,7 +393,8 @@ int ZEXPORT gzread(file, buf, len)
 
     /* since an int is returned, make sure len fits in one, otherwise return
        with an error (this avoids the flaw in the interface) */
-    if ((int)len < 0) {
+    if ((int)len < 0)
+    {
         gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
         return -1;
     }
@@ -344,17 +404,22 @@ int ZEXPORT gzread(file, buf, len)
         return 0;
 
     /* process a skip request */
-    if (state->seek) {
+    if (state->seek)
+    {
         state->seek = 0;
+
         if (gz_skip(state, state->skip) == -1)
             return -1;
     }
 
     /* get len bytes to buf, or less than len if at the end */
     got = 0;
-    do {
+
+    do
+    {
         /* first just try copying data from the output buffer */
-        if (state->x.have) {
+        if (state->x.have)
+        {
             n = state->x.have > len ? len : state->x.have;
             memcpy(buf, state->x.next, n);
             state->x.next += n;
@@ -362,44 +427,52 @@ int ZEXPORT gzread(file, buf, len)
         }
 
         /* output buffer empty -- return if we're at the end of the input */
-        else if (state->eof && strm->avail_in == 0) {
+        else if (state->eof && strm->avail_in == 0)
+        {
             state->past = 1;        /* tried to read past end */
             break;
         }
 
         /* need output data -- for small len or new stream load up our output
            buffer */
-        else if (state->how == LOOK || len < (state->size << 1)) {
+        else if (state->how == LOOK || len < (state->size << 1))
+        {
             /* get more output, looking for header if required */
             if (gz_fetch(state) == -1)
                 return -1;
+
             continue;       /* no progress yet -- go back to copy above */
             /* the copy above assures that we will leave with space in the
                output buffer, allowing at least one gzungetc() to succeed */
         }
 
         /* large len -- read directly into user buffer */
-        else if (state->how == COPY) {      /* read directly */
+        else if (state->how == COPY)        /* read directly */
+        {
             if (gz_load(state, buf, len, &n) == -1)
                 return -1;
         }
 
         /* large len -- decompress directly into user buffer */
-        else {  /* state->how == GZIP */
+        else    /* state->how == GZIP */
+        {
             strm->avail_out = len;
             strm->next_out = buf;
+
             if (gz_decomp(state) == -1)
                 return -1;
+
             n = state->x.have;
             state->x.have = 0;
         }
 
         /* update progress */
         len -= n;
-        buf = (char *)buf + n;
+        buf = (char*)buf + n;
         got += n;
         state->x.pos += n;
-    } while (len);
+    }
+    while (len);
 
     /* return number of bytes read into user buffer (will fit in int) */
     return (int)got;
@@ -411,7 +484,7 @@ int ZEXPORT gzread(file, buf, len)
 int ZEXPORT gzgetc(gzFile file)
 #else
 int ZEXPORT gzgetc(file)
-    gzFile file;
+gzFile file;
 #endif
 {
     int ret;
@@ -421,6 +494,7 @@ int ZEXPORT gzgetc(file)
     /* get internal structure */
     if (file == NULL)
         return -1;
+
     state = (gz_statep)file;
 
     /* check that we're reading and that there's no (serious) error */
@@ -429,7 +503,8 @@ int ZEXPORT gzgetc(file)
         return -1;
 
     /* try output buffer (no need to check for skip request) */
-    if (state->x.have) {
+    if (state->x.have)
+    {
         state->x.have--;
         state->x.pos++;
         return *(state->x.next)++;
@@ -455,8 +530,8 @@ gzFile file;
 int ZEXPORT gzungetc(signed char c, gzFile file)
 #else
 int ZEXPORT gzungetc(c, file)
-    int c;
-    gzFile file;
+int c;
+gzFile file;
 #endif
 {
     gz_statep state;
@@ -464,6 +539,7 @@ int ZEXPORT gzungetc(c, file)
     /* get internal structure */
     if (file == NULL)
         return -1;
+
     state = (gz_statep)file;
 
     /* check that we're reading and that there's no (serious) error */
@@ -472,8 +548,10 @@ int ZEXPORT gzungetc(c, file)
         return -1;
 
     /* process a skip request */
-    if (state->seek) {
+    if (state->seek)
+    {
         state->seek = 0;
+
         if (gz_skip(state, state->skip) == -1)
             return -1;
     }
@@ -483,7 +561,8 @@ int ZEXPORT gzungetc(c, file)
         return -1;
 
     /* if output buffer empty, put byte at end (allows more pushing) */
-    if (state->x.have == 0) {
+    if (state->x.have == 0)
+    {
         state->x.have = 1;
         state->x.next = state->out + (state->size << 1) - 1;
         state->x.next[0] = c;
@@ -493,19 +572,24 @@ int ZEXPORT gzungetc(c, file)
     }
 
     /* if no room, give up (must have already done a gzungetc()) */
-    if (state->x.have == (state->size << 1)) {
+    if (state->x.have == (state->size << 1))
+    {
         gz_error(state, Z_DATA_ERROR, "out of room to push characters");
         return -1;
     }
 
     /* slide output data if needed and insert byte before existing data */
-    if (state->x.next == state->out) {
-        unsigned char *src = state->out + state->x.have;
-        unsigned char *dest = state->out + (state->size << 1);
+    if (state->x.next == state->out)
+    {
+        unsigned char* src = state->out + state->x.have;
+        unsigned char* dest = state->out + (state->size << 1);
+
         while (src > state->out)
             *--dest = *--src;
+
         state->x.next = dest;
     }
+
     state->x.have++;
     state->x.next--;
     state->x.next[0] = c;
@@ -516,22 +600,23 @@ int ZEXPORT gzungetc(c, file)
 
 /* -- see zlib.h -- */
 #ifdef WIN32
-char * ZEXPORT gzgets(gzFile file, char *buf, int len)
+char* ZEXPORT gzgets(gzFile file, char* buf, int len)
 #else
-char * ZEXPORT gzgets(file, buf, len)
-    gzFile file;
-    char *buf;
-    int len;
+char* ZEXPORT gzgets(file, buf, len)
+gzFile file;
+char* buf;
+int len;
 #endif
 {
     unsigned left, n;
-    char *str;
-    unsigned char *eol;
+    char* str;
+    unsigned char* eol;
     gz_statep state;
 
     /* check parameters and get internal structure */
     if (file == NULL || buf == NULL || len < 1)
         return NULL;
+
     state = (gz_statep)file;
 
     /* check that we're reading and that there's no (serious) error */
@@ -540,8 +625,10 @@ char * ZEXPORT gzgets(file, buf, len)
         return NULL;
 
     /* process a skip request */
-    if (state->seek) {
+    if (state->seek)
+    {
         state->seek = 0;
+
         if (gz_skip(state, state->skip) == -1)
             return NULL;
     }
@@ -551,11 +638,15 @@ char * ZEXPORT gzgets(file, buf, len)
        the contents, let the user worry about that) */
     str = buf;
     left = (unsigned)len - 1;
-    if (left) do {
+
+    if (left) do
+        {
             /* assure that something is in the output buffer */
             if (state->x.have == 0 && gz_fetch(state) == -1)
                 return NULL;                /* error */
-        if (state->x.have == 0) {       /* end of file */
+
+            if (state->x.have == 0)         /* end of file */
+            {
                 state->past = 1;            /* read past end */
                 break;                      /* return what we have */
             }
@@ -563,6 +654,7 @@ char * ZEXPORT gzgets(file, buf, len)
             /* look for end-of-line in current output buffer */
             n = state->x.have > left ? left : state->x.have;
             eol = memchr(state->x.next, '\n', n);
+
             if (eol != NULL)
                 n = (unsigned)(eol - state->x.next) + 1;
 
@@ -573,11 +665,13 @@ char * ZEXPORT gzgets(file, buf, len)
             state->x.pos += n;
             left -= n;
             buf += n;
-    } while (left && eol == NULL);
+        }
+        while (left && eol == NULL);
 
     /* return terminated string, or if nothing, end of file */
     if (buf == str)
         return NULL;
+
     buf[0] = 0;
     return str;
 }
@@ -587,7 +681,7 @@ char * ZEXPORT gzgets(file, buf, len)
 int ZEXPORT gzdirect(gzFile file)
 #else
 int ZEXPORT gzdirect(file)
-    gzFile file;
+gzFile file;
 #endif
 {
     gz_statep state;
@@ -595,6 +689,7 @@ int ZEXPORT gzdirect(file)
     /* get internal structure */
     if (file == NULL)
         return 0;
+
     state = (gz_statep)file;
 
     /* if the state is not known, but we can find out, then do so (this is
@@ -611,7 +706,7 @@ int ZEXPORT gzdirect(file)
 int ZEXPORT gzclose_r(gzFile file)
 #else
 int ZEXPORT gzclose_r(file)
-    gzFile file;
+gzFile file;
 #endif
 {
     int ret, err;
@@ -620,6 +715,7 @@ int ZEXPORT gzclose_r(file)
     /* get internal structure */
     if (file == NULL)
         return Z_STREAM_ERROR;
+
     state = (gz_statep)file;
 
     /* check that we're reading */
@@ -627,11 +723,13 @@ int ZEXPORT gzclose_r(file)
         return Z_STREAM_ERROR;
 
     /* free memory and close file */
-    if (state->size) {
+    if (state->size)
+    {
         inflateEnd(&(state->strm));
         free(state->out);
         free(state->in);
     }
+
     err = state->err == Z_BUF_ERROR ? Z_BUF_ERROR : Z_OK;
     gz_error(state, Z_OK, NULL);
     free(state->path);

extern/zlib/gzwrite.c

@@ -16,7 +16,7 @@ local int gz_zero OF((gz_statep, z_off64_t));
 local int gz_init(gz_statep state)
 #else
 local int gz_init(state)
-    gz_statep state;
+gz_statep state;
 #endif
 {
     int ret;
@@ -24,16 +24,21 @@ local int gz_init(state)
 
     /* allocate input buffer */
     state->in = malloc(state->want);
-    if (state->in == NULL) {
+
+    if (state->in == NULL)
+    {
         gz_error(state, Z_MEM_ERROR, "out of memory");
         return -1;
     }
 
     /* only need output buffer and deflate state if compressing */
-    if (!state->direct) {
+    if (!state->direct)
+    {
         /* allocate output buffer */
         state->out = malloc(state->want);
-        if (state->out == NULL) {
+
+        if (state->out == NULL)
+        {
             free(state->in);
             gz_error(state, Z_MEM_ERROR, "out of memory");
             return -1;
@@ -45,7 +50,9 @@ local int gz_init(state)
         strm->opaque = Z_NULL;
         ret = deflateInit2(strm, state->level, Z_DEFLATED,
                            MAX_WBITS + 16, DEF_MEM_LEVEL, state->strategy);
-        if (ret != Z_OK) {
+
+        if (ret != Z_OK)
+        {
             free(state->out);
             free(state->in);
             gz_error(state, Z_MEM_ERROR, "out of memory");
@@ -57,11 +64,13 @@ local int gz_init(state)
     state->size = state->want;
 
     /* initialize write buffer if compressing */
-    if (!state->direct) {
+    if (!state->direct)
+    {
         strm->avail_out = state->size;
         strm->next_out = state->out;
         state->x.next = strm->next_out;
     }
+
     return 0;
 }
 
@@ -75,8 +84,8 @@ local int gz_init(state)
 local int gz_comp(gz_statep state, int flush)
 #else
 local int gz_comp(state, flush)
-    gz_statep state;
-    int flush;
+gz_statep state;
+int flush;
 #endif
 {
     int ret, got;
@@ -88,46 +97,62 @@ local int gz_comp(state, flush)
         return -1;
 
     /* write directly if requested */
-    if (state->direct) {
+    if (state->direct)
+    {
         got = write(state->fd, strm->next_in, strm->avail_in);
-        if (got < 0 || (unsigned)got != strm->avail_in) {
+
+        if (got < 0 || (unsigned)got != strm->avail_in)
+        {
             gz_error(state, Z_ERRNO, zstrerror());
             return -1;
         }
+
         strm->avail_in = 0;
         return 0;
     }
 
     /* run deflate() on provided input until it produces no more output */
     ret = Z_OK;
-    do {
+
+    do
+    {
         /* write out current buffer contents if full, or if flushing, but if
            doing Z_FINISH then don't write until we get to Z_STREAM_END */
         if (strm->avail_out == 0 || (flush != Z_NO_FLUSH &&
-            (flush != Z_FINISH || ret == Z_STREAM_END))) {
+                                     (flush != Z_FINISH || ret == Z_STREAM_END)))
+        {
             have = (unsigned)(strm->next_out - state->x.next);
+
             if (have && ((got = write(state->fd, state->x.next, have)) < 0 ||
-                         (unsigned)got != have)) {
+                         (unsigned)got != have))
+            {
                 gz_error(state, Z_ERRNO, zstrerror());
                 return -1;
             }
-            if (strm->avail_out == 0) {
+
+            if (strm->avail_out == 0)
+            {
                 strm->avail_out = state->size;
                 strm->next_out = state->out;
             }
+
             state->x.next = strm->next_out;
         }
 
         /* compress */
         have = strm->avail_out;
         ret = deflate(strm, flush);
-        if (ret == Z_STREAM_ERROR) {
+
+        if (ret == Z_STREAM_ERROR)
+        {
             gz_error(state, Z_STREAM_ERROR,
                      "internal error: deflate stream corrupt");
             return -1;
         }
+
         have -= strm->avail_out;
-    } while (have);
+    }
+    while (have);
 
     /* if that completed a deflate stream, allow another to start */
     if (flush == Z_FINISH)
@@ -142,8 +167,8 @@ local int gz_comp(state, flush)
 local int gz_zero(gz_statep state, z_off64_t len)
 #else
 local int gz_zero(state, len)
-    gz_statep state;
-    z_off64_t len;
+gz_statep state;
+z_off64_t len;
 #endif
 {
     int first;
@@ -156,20 +181,28 @@ local int gz_zero(state, len)
 
     /* compress len zeros (len guaranteed > 0) */
     first = 1;
-    while (len) {
+
+    while (len)
+    {
         n = GT_OFF(state->size) || (z_off64_t)state->size > len ?
             (unsigned)len : state->size;
-        if (first) {
+
+        if (first)
+        {
             memset(state->in, 0, n);
             first = 0;
         }
+
         strm->avail_in = n;
         strm->next_in = state->in;
         state->x.pos += n;
+
         if (gz_comp(state, Z_NO_FLUSH) == -1)
             return -1;
+
         len -= n;
     }
+
     return 0;
 }
 
@@ -178,9 +211,9 @@ local int gz_zero(state, len)
 int ZEXPORT gzwrite(gzFile file, voidpc buf, unsigned len)
 #else
 int ZEXPORT gzwrite(file, buf, len)
-    gzFile file;
-    voidpc buf;
-    unsigned len;
+gzFile file;
+voidpc buf;
+unsigned len;
 #endif
 {
     unsigned put = len;
@@ -191,6 +224,7 @@ int ZEXPORT gzwrite(file, buf, len)
     /* get internal structure */
     if (file == NULL)
         return 0;
+
     state = (gz_statep)file;
     strm = &(state->strm);
 
@@ -200,7 +234,8 @@ int ZEXPORT gzwrite(file, buf, len)
 
     /* since an int is returned, make sure len fits in one, otherwise return
        with an error (this avoids the flaw in the interface) */
-    if ((int)len < 0) {
+    if ((int)len < 0)
+    {
         gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
         return 0;
     }
@@ -214,31 +249,41 @@ int ZEXPORT gzwrite(file, buf, len)
         return 0;
 
     /* check for seek request */
-    if (state->seek) {
+    if (state->seek)
+    {
         state->seek = 0;
+
         if (gz_zero(state, state->skip) == -1)
             return 0;
     }
 
     /* for small len, copy to input buffer, otherwise compress directly */
-    if (len < state->size) {
+    if (len < state->size)
+    {
         /* copy to input buffer, compress when full */
-        do {
+        do
+        {
             if (strm->avail_in == 0)
                 strm->next_in = state->in;
+
             n = state->size - strm->avail_in;
+
             if (n > len)
                 n = len;
+
             memcpy(strm->next_in + strm->avail_in, buf, n);
             strm->avail_in += n;
             state->x.pos += n;
-            buf = (char *)buf + n;
+            buf = (char*)buf + n;
             len -= n;
+
             if (len && gz_comp(state, Z_NO_FLUSH) == -1)
                 return 0;
-        } while (len);
         }
-    else {
+        while (len);
+    }
+    else
+    {
         /* consume whatever's left in the input buffer */
         if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
             return 0;
@@ -247,6 +292,7 @@ int ZEXPORT gzwrite(file, buf, len)
         strm->avail_in = len;
         strm->next_in = (voidp)buf;
         state->x.pos += len;
+
         if (gz_comp(state, Z_NO_FLUSH) == -1)
             return 0;
     }
@@ -260,8 +306,8 @@ int ZEXPORT gzwrite(file, buf, len)
 int ZEXPORT gzputc(gzFile file, unsigned char c)
 #else
 int ZEXPORT gzputc(file, c)
-    gzFile file;
-    int c;
+gzFile file;
+int c;
 #endif
 {
     unsigned char buf[1];
@@ -271,6 +317,7 @@ int ZEXPORT gzputc(file, c)
     /* get internal structure */
     if (file == NULL)
         return -1;
+
     state = (gz_statep)file;
     strm = &(state->strm);
 
@@ -279,17 +326,21 @@ int ZEXPORT gzputc(file, c)
         return -1;
 
     /* check for seek request */
-    if (state->seek) {
+    if (state->seek)
+    {
         state->seek = 0;
+
         if (gz_zero(state, state->skip) == -1)
             return -1;
     }
 
     /* try writing to input buffer for speed (state->size == 0 if buffer not
        initialized) */
-    if (strm->avail_in < state->size) {
+    if (strm->avail_in < state->size)
+    {
         if (strm->avail_in == 0)
             strm->next_in = state->in;
+
         strm->next_in[strm->avail_in++] = c;
         state->x.pos++;
         return c & 0xff;
@@ -297,18 +348,20 @@ int ZEXPORT gzputc(file, c)
 
     /* no room in buffer or not initialized, use gz_write() */
     buf[0] = c;
+
     if (gzwrite(file, buf, 1) != 1)
         return -1;
+
     return c & 0xff;
 }
 
 /* -- see zlib.h -- */
 #ifdef WIN32
-int ZEXPORT gzputs(gzFile file, const char *str)
+int ZEXPORT gzputs(gzFile file, const char* str)
 #else
 int ZEXPORT gzputs(file, str)
-    gzFile file;
-    const char *str;
+gzFile file;
+const char* str;
 #endif
 {
     int ret;
@@ -324,7 +377,7 @@ int ZEXPORT gzputs(file, str)
 #include <stdarg.h>
 
 /* -- see zlib.h -- */
-int ZEXPORTVA gzprintf (gzFile file, const char *format, ...)
+int ZEXPORTVA gzprintf(gzFile file, const char* format, ...)
 {
     int size, len;
     gz_statep state;
@@ -334,6 +387,7 @@ int ZEXPORTVA gzprintf (gzFile file, const char *format, ...)
     /* get internal structure */
     if (file == NULL)
         return -1;
+
     state = (gz_statep)file;
     strm = &(state->strm);
 
@@ -346,8 +400,10 @@ int ZEXPORTVA gzprintf (gzFile file, const char *format, ...)
         return 0;
 
     /* check for seek request */
-    if (state->seek) {
+    if (state->seek)
+    {
         state->seek = 0;
+
         if (gz_zero(state, state->skip) == -1)
             return 0;
     }
@@ -362,21 +418,23 @@ int ZEXPORTVA gzprintf (gzFile file, const char *format, ...)
     va_start(va, format);
 #ifdef NO_vsnprintf
 #  ifdef HAS_vsprintf_void
-    (void)vsprintf((char *)(state->in), format, va);
+    (void)vsprintf((char*)(state->in), format, va);
     va_end(va);
+
     for (len = 0; len < size; len++)
         if (state->in[len] == 0) break;
+
 #  else
-    len = vsprintf((char *)(state->in), format, va);
+    len = vsprintf((char*)(state->in), format, va);
     va_end(va);
 #  endif
 #else
 #  ifdef HAS_vsnprintf_void
-    (void)vsnprintf((char *)(state->in), size, format, va);
+    (void)vsnprintf((char*)(state->in), size, format, va);
     va_end(va);
-    len = strlen((char *)(state->in));
+    len = strlen((char*)(state->in));
 #  else
-    len = vsnprintf((char *)(state->in), size, format, va);
+    len = vsnprintf((char*)(state->in), size, format, va);
     va_end(va);
 #  endif
 #endif
@@ -395,11 +453,11 @@ int ZEXPORTVA gzprintf (gzFile file, const char *format, ...)
 #else /* !STDC && !Z_HAVE_STDARG_H */
 
 /* -- see zlib.h -- */
-int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
+int ZEXPORTVA gzprintf(file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
                        a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
-    gzFile file;
-    const char *format;
-    int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
+gzFile file;
+const char* format;
+int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
     a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
 {
     int size, len;
@@ -409,11 +467,12 @@ int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
     /* get internal structure */
     if (file == NULL)
         return -1;
+
     state = (gz_statep)file;
     strm = &(state->strm);
 
     /* check that can really pass pointer in ints */
-    if (sizeof(int) != sizeof(void *))
+    if (sizeof(int) != sizeof(void*))
         return 0;
 
     /* check that we're writing and that there's no error */
@@ -425,8 +484,10 @@ int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
         return 0;
 
     /* check for seek request */
-    if (state->seek) {
+    if (state->seek)
+    {
         state->seek = 0;
+
         if (gz_zero(state, state->skip) == -1)
             return 0;
     }
@@ -440,21 +501,23 @@ int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
     state->in[size - 1] = 0;
 #ifdef NO_snprintf
 #  ifdef HAS_sprintf_void
-    sprintf((char *)(state->in), format, a1, a2, a3, a4, a5, a6, a7, a8,
+    sprintf((char*)(state->in), format, a1, a2, a3, a4, a5, a6, a7, a8,
             a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+
     for (len = 0; len < size; len++)
         if (state->in[len] == 0) break;
+
 #  else
-    len = sprintf((char *)(state->in), format, a1, a2, a3, a4, a5, a6, a7, a8,
+    len = sprintf((char*)(state->in), format, a1, a2, a3, a4, a5, a6, a7, a8,
                   a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
 #  endif
 #else
 #  ifdef HAS_snprintf_void
-    snprintf((char *)(state->in), size, format, a1, a2, a3, a4, a5, a6, a7, a8,
+    snprintf((char*)(state->in), size, format, a1, a2, a3, a4, a5, a6, a7, a8,
              a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
-    len = strlen((char *)(state->in));
+    len = strlen((char*)(state->in));
 #  else
-    len = snprintf((char *)(state->in), size, format, a1, a2, a3, a4, a5, a6,
+    len = snprintf((char*)(state->in), size, format, a1, a2, a3, a4, a5, a6,
                    a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18,
                    a19, a20);
 #  endif
@@ -478,8 +541,8 @@ int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
 int ZEXPORT gzflush(gzFile file, int flush)
 #else
 int ZEXPORT gzflush(file, flush)
-    gzFile file;
-    int flush;
+gzFile file;
+int flush;
 #endif
 {
     gz_statep state;
@@ -487,6 +550,7 @@ int ZEXPORT gzflush(file, flush)
     /* get internal structure */
     if (file == NULL)
         return -1;
+
     state = (gz_statep)file;
 
     /* check that we're writing and that there's no error */
@@ -498,8 +562,10 @@ int ZEXPORT gzflush(file, flush)
         return Z_STREAM_ERROR;
 
     /* check for seek request */
-    if (state->seek) {
+    if (state->seek)
+    {
         state->seek = 0;
+
         if (gz_zero(state, state->skip) == -1)
             return -1;
     }
@@ -514,9 +580,9 @@ int ZEXPORT gzflush(file, flush)
 int ZEXPORT gzsetparams(gzFile file, int level, int strategy)
 #else
 int ZEXPORT gzsetparams(file, level, strategy)
-    gzFile file;
-    int level;
-    int strategy;
+gzFile file;
+int level;
+int strategy;
 #endif
 {
     gz_statep state;
@@ -525,6 +591,7 @@ int ZEXPORT gzsetparams(file, level, strategy)
     /* get internal structure */
     if (file == NULL)
         return Z_STREAM_ERROR;
+
     state = (gz_statep)file;
     strm = &(state->strm);
 
@@ -537,19 +604,24 @@ int ZEXPORT gzsetparams(file, level, strategy)
         return Z_OK;
 
     /* check for seek request */
-    if (state->seek) {
+    if (state->seek)
+    {
         state->seek = 0;
+
         if (gz_zero(state, state->skip) == -1)
             return -1;
     }
 
     /* change compression parameters for subsequent input */
-    if (state->size) {
+    if (state->size)
+    {
         /* flush previous input with previous parameters before changing */
         if (strm->avail_in && gz_comp(state, Z_PARTIAL_FLUSH) == -1)
             return state->err;
+
         deflateParams(strm, level, strategy);
     }
+
     state->level = level;
     state->strategy = strategy;
     return Z_OK;
@@ -560,7 +632,7 @@ int ZEXPORT gzsetparams(file, level, strategy)
 int ZEXPORT gzclose_w(gzFile file)
 #else
 int ZEXPORT gzclose_w(file)
-    gzFile file;
+gzFile file;
 #endif
 {
     int ret = Z_OK;
@@ -569,6 +641,7 @@ int ZEXPORT gzclose_w(file)
     /* get internal structure */
     if (file == NULL)
         return Z_STREAM_ERROR;
+
     state = (gz_statep)file;
 
     /* check that we're writing */
@@ -576,26 +649,35 @@ int ZEXPORT gzclose_w(file)
         return Z_STREAM_ERROR;
 
     /* check for seek request */
-    if (state->seek) {
+    if (state->seek)
+    {
         state->seek = 0;
+
         if (gz_zero(state, state->skip) == -1)
             ret = state->err;
     }
 
     /* flush, free memory, and close file */
-    if (state->size) {
+    if (state->size)
+    {
         if (gz_comp(state, Z_FINISH) == -1)
             ret = state->err;
-        if (!state->direct) {
+
+        if (!state->direct)
+        {
             (void)deflateEnd(&(state->strm));
             free(state->out);
         }
+
         free(state->in);
     }
+
     gz_error(state, Z_OK, NULL);
     free(state->path);
+
     if (close(state->fd) == -1)
         ret = Z_ERRNO;
+
     free(state);
     return ret;
 }

extern/zlib/infback.c

@@ -33,7 +33,7 @@ while (0) \
 #endif
 
 /* function prototypes */
-local void fixedtables OF((struct inflate_state FAR *state));
+local void fixedtables OF((struct inflate_state FAR* state));
 
 /*
    strm provides memory allocation functions in zalloc and zfree, or
@@ -43,26 +43,30 @@ local void fixedtables OF((struct inflate_state FAR *state));
    window and output buffer that is 2**windowBits bytes.
  */
 #ifdef WIN32
-int ZEXPORT inflateBackInit_(z_streamp strm, int windowBits, unsigned char FAR *window, const char *version, int stream_size)
+int ZEXPORT inflateBackInit_(z_streamp strm, int windowBits, unsigned char FAR* window, const char* version, int stream_size)
 #else
 int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
 z_streamp strm;
 int windowBits;
-unsigned char FAR *window;
-const char *version;
+unsigned char FAR* window;
+const char* version;
 int stream_size;
 #endif
 {
-    struct inflate_state FAR *state;
+    struct inflate_state FAR* state;
 
     if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
             stream_size != (int)(sizeof(z_stream)))
         return Z_VERSION_ERROR;
+
     if (strm == Z_NULL || window == Z_NULL ||
             windowBits < 8 || windowBits > 15)
         return Z_STREAM_ERROR;
+
     strm->msg = Z_NULL;                 /* in case we return an error */
-    if (strm->zalloc == (alloc_func)0) {
+
+    if (strm->zalloc == (alloc_func)0)
+    {
 #ifdef Z_SOLO
         return Z_STREAM_ERROR;
 #else
@@ -70,17 +74,21 @@ int stream_size;
         strm->opaque = (voidpf)0;
 #endif
     }
+
     if (strm->zfree == (free_func)0)
 #ifdef Z_SOLO
         return Z_STREAM_ERROR;
+
 #else
         strm->zfree = zcfree;
 #endif
-    state = (struct inflate_state FAR *)ZALLOC(strm, 1,
+    state = (struct inflate_state FAR*)ZALLOC(strm, 1,
             sizeof(struct inflate_state));
+
     if (state == Z_NULL) return Z_MEM_ERROR;
+
     Tracev((stderr, "inflate: allocated\n"));
-    strm->state = (struct internal_state FAR *)state;
+    strm->state = (struct internal_state FAR*)state;
     state->dmax = 32768U;
     state->wbits = windowBits;
     state->wsize = 1U << windowBits;
@@ -101,28 +109,34 @@ int stream_size;
    may not be thread-safe.
  */
 #ifdef WIN32
-local void fixedtables(struct inflate_state FAR *state)
+local void fixedtables(struct inflate_state FAR* state)
 #else
 local void fixedtables(state)
-struct inflate_state FAR *state;
+struct inflate_state FAR* state;
 #endif
 {
 #ifdef BUILDFIXED
     static int virgin = 1;
-    static code *lenfix, *distfix;
+    static code* lenfix, *distfix;
     static code fixed[544];
 
     /* build fixed huffman tables if first call (may not be thread safe) */
-    if (virgin) {
+    if (virgin)
+    {
         unsigned sym, bits;
-        static code *next;
+        static code* next;
 
         /* literal/length table */
         sym = 0;
+
         while (sym < 144) state->lens[sym++] = 8;
+
         while (sym < 256) state->lens[sym++] = 9;
+
         while (sym < 280) state->lens[sym++] = 7;
+
         while (sym < 288) state->lens[sym++] = 8;
+
         next = fixed;
         lenfix = next;
         bits = 9;
@@ -130,7 +144,9 @@ struct inflate_state FAR *state;
 
         /* distance table */
         sym = 0;
+
         while (sym < 32) state->lens[sym++] = 5;
+
         distfix = next;
         bits = 5;
         inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
@@ -138,6 +154,7 @@ struct inflate_state FAR *state;
         /* do this just once */
         virgin = 0;
     }
+
 #else /* !BUILDFIXED */
 #   include "inffixed.h"
 #endif /* BUILDFIXED */
@@ -273,24 +290,24 @@ struct inflate_state FAR *state;
    are not correct, i.e. strm is Z_NULL or the state was not initialized.
  */
 #ifdef WIN32
-int ZEXPORT inflateBack(z_streamp strm, in_func in, void FAR *in_desc, out_func out, void FAR *out_desc)
+int ZEXPORT inflateBack(z_streamp strm, in_func in, void FAR* in_desc, out_func out, void FAR* out_desc)
 #else
 int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
 z_streamp strm;
 in_func in;
-void FAR *in_desc;
+void FAR* in_desc;
 out_func out;
-void FAR *out_desc;
+void FAR* out_desc;
 #endif
 {
-    struct inflate_state FAR *state;
-    unsigned char FAR *next;    /* next input */
-    unsigned char FAR *put;     /* next output */
+    struct inflate_state FAR* state;
+    unsigned char FAR* next;    /* next input */
+    unsigned char FAR* put;     /* next output */
     unsigned have, left;        /* available input and output */
     unsigned long hold;         /* bit buffer */
     unsigned bits;              /* bits in bit buffer */
     unsigned copy;              /* number of stored or match bytes to copy */
-    unsigned char FAR *from;    /* where to copy match bytes from */
+    unsigned char FAR* from;    /* where to copy match bytes from */
     code here;                  /* current decoding table entry */
     code last;                  /* parent table entry */
     unsigned len;               /* length to copy for repeats, bits to drop */
@@ -301,7 +318,8 @@ void FAR *out_desc;
     /* Check that the strm exists and that the state was initialized */
     if (strm == Z_NULL || strm->state == Z_NULL)
         return Z_STREAM_ERROR;
-    state = (struct inflate_state FAR *)strm->state;
+
+    state = (struct inflate_state FAR*)strm->state;
 
     /* Reset the state */
     strm->msg = Z_NULL;
@@ -317,38 +335,48 @@ void FAR *out_desc;
 
     /* Inflate until end of block marked as last */
     for (;;)
-        switch (state->mode) {
+        switch (state->mode)
+        {
             case TYPE:
+
                 /* determine and dispatch block type */
-            if (state->last) {
+                if (state->last)
+                {
                     BYTEBITS();
                     state->mode = DONE;
                     break;
                 }
+
                 NEEDBITS(3);
                 state->last = BITS(1);
                 DROPBITS(1);
-            switch (BITS(2)) {
+
+                switch (BITS(2))
+                {
                     case 0:                             /* stored block */
                         Tracev((stderr, "inflate:     stored block%s\n",
                                 state->last ? " (last)" : ""));
                         state->mode = STORED;
                         break;
+
                     case 1:                             /* fixed block */
                         fixedtables(state);
                         Tracev((stderr, "inflate:     fixed codes block%s\n",
                                 state->last ? " (last)" : ""));
                         state->mode = LEN;              /* decode codes */
                         break;
+
                     case 2:                             /* dynamic block */
                         Tracev((stderr, "inflate:     dynamic codes block%s\n",
                                 state->last ? " (last)" : ""));
                         state->mode = TABLE;
                         break;
+
                     case 3:
-                strm->msg = (char *)"invalid block type";
+                        strm->msg = (char*)"invalid block type";
                         state->mode = BAD;
                 }
+
                 DROPBITS(2);
                 break;
 
@@ -356,23 +384,30 @@ void FAR *out_desc;
                 /* get and verify stored block length */
                 BYTEBITS();                         /* go to byte boundary */
                 NEEDBITS(32);
-            if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
-                strm->msg = (char *)"invalid stored block lengths";
+
+                if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff))
+                {
+                    strm->msg = (char*)"invalid stored block lengths";
                     state->mode = BAD;
                     break;
                 }
+
                 state->length = (unsigned)hold & 0xffff;
                 Tracev((stderr, "inflate:       stored length %u\n",
                         state->length));
                 INITBITS();
 
                 /* copy stored block from input to output */
-            while (state->length != 0) {
+                while (state->length != 0)
+                {
                     copy = state->length;
                     PULL();
                     ROOM();
+
                     if (copy > have) copy = have;
+
                     if (copy > left) copy = left;
+
                     zmemcpy(put, next, copy);
                     have -= copy;
                     next += copy;
@@ -380,6 +415,7 @@ void FAR *out_desc;
                     put += copy;
                     state->length -= copy;
                 }
+
                 Tracev((stderr, "inflate:       stored end\n"));
                 state->mode = TYPE;
                 break;
@@ -394,79 +430,106 @@ void FAR *out_desc;
                 state->ncode = BITS(4) + 4;
                 DROPBITS(4);
 #ifndef PKZIP_BUG_WORKAROUND
-            if (state->nlen > 286 || state->ndist > 30) {
-                strm->msg = (char *)"too many length or distance symbols";
+
+                if (state->nlen > 286 || state->ndist > 30)
+                {
+                    strm->msg = (char*)"too many length or distance symbols";
                     state->mode = BAD;
                     break;
                 }
+
 #endif
                 Tracev((stderr, "inflate:       table sizes ok\n"));
 
                 /* get code length code lengths (not a typo) */
                 state->have = 0;
-            while (state->have < state->ncode) {
+
+                while (state->have < state->ncode)
+                {
                     NEEDBITS(3);
                     state->lens[order[state->have++]] = (unsigned short)BITS(3);
                     DROPBITS(3);
                 }
+
                 while (state->have < 19)
                     state->lens[order[state->have++]] = 0;
+
                 state->next = state->codes;
-            state->lencode = (code const FAR *)(state->next);
+                state->lencode = (code const FAR*)(state->next);
                 state->lenbits = 7;
                 ret = inflate_table(CODES, state->lens, 19, &(state->next),
                                     &(state->lenbits), state->work);
-            if (ret) {
-                strm->msg = (char *)"invalid code lengths set";
+
+                if (ret)
+                {
+                    strm->msg = (char*)"invalid code lengths set";
                     state->mode = BAD;
                     break;
                 }
+
                 Tracev((stderr, "inflate:       code lengths ok\n"));
 
                 /* get length and distance code code lengths */
                 state->have = 0;
-            while (state->have < state->nlen + state->ndist) {
-                for (;;) {
+
+                while (state->have < state->nlen + state->ndist)
+                {
+                    for (;;)
+                    {
                         here = state->lencode[BITS(state->lenbits)];
+
                         if ((unsigned)(here.bits) <= bits) break;
+
                         PULLBYTE();
                     }
-                if (here.val < 16) {
+
+                    if (here.val < 16)
+                    {
                         DROPBITS(here.bits);
                         state->lens[state->have++] = here.val;
                     }
-                else {
-                    if (here.val == 16) {
+                    else
+                    {
+                        if (here.val == 16)
+                        {
                             NEEDBITS(here.bits + 2);
                             DROPBITS(here.bits);
-                        if (state->have == 0) {
-                            strm->msg = (char *)"invalid bit length repeat";
+
+                            if (state->have == 0)
+                            {
+                                strm->msg = (char*)"invalid bit length repeat";
                                 state->mode = BAD;
                                 break;
                             }
+
                             len = (unsigned)(state->lens[state->have - 1]);
                             copy = 3 + BITS(2);
                             DROPBITS(2);
                         }
-                    else if (here.val == 17) {
+                        else if (here.val == 17)
+                        {
                             NEEDBITS(here.bits + 3);
                             DROPBITS(here.bits);
                             len = 0;
                             copy = 3 + BITS(3);
                             DROPBITS(3);
                         }
-                    else {
+                        else
+                        {
                             NEEDBITS(here.bits + 7);
                             DROPBITS(here.bits);
                             len = 0;
                             copy = 11 + BITS(7);
                             DROPBITS(7);
                         }
-                    if (state->have + copy > state->nlen + state->ndist) {
-                        strm->msg = (char *)"invalid bit length repeat";
+
+                        if (state->have + copy > state->nlen + state->ndist)
+                        {
+                            strm->msg = (char*)"invalid bit length repeat";
                             state->mode = BAD;
                             break;
                         }
+
                         while (copy--)
                             state->lens[state->have++] = (unsigned short)len;
                     }
@@ -476,8 +539,9 @@ void FAR *out_desc;
                 if (state->mode == BAD) break;
 
                 /* check for end-of-block code (better have one) */
-            if (state->lens[256] == 0) {
-                strm->msg = (char *)"invalid code -- missing end-of-block";
+                if (state->lens[256] == 0)
+                {
+                    strm->msg = (char*)"invalid code -- missing end-of-block";
                     state->mode = BAD;
                     break;
                 }
@@ -486,59 +550,81 @@ void FAR *out_desc;
                    values here (9 and 6) without reading the comments in inftrees.h
                    concerning the ENOUGH constants, which depend on those values */
                 state->next = state->codes;
-            state->lencode = (code const FAR *)(state->next);
+                state->lencode = (code const FAR*)(state->next);
                 state->lenbits = 9;
                 ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
                                     &(state->lenbits), state->work);
-            if (ret) {
-                strm->msg = (char *)"invalid literal/lengths set";
+
+                if (ret)
+                {
+                    strm->msg = (char*)"invalid literal/lengths set";
                     state->mode = BAD;
                     break;
                 }
-            state->distcode = (code const FAR *)(state->next);
+
+                state->distcode = (code const FAR*)(state->next);
                 state->distbits = 6;
                 ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
                                     &(state->next), &(state->distbits), state->work);
-            if (ret) {
-                strm->msg = (char *)"invalid distances set";
+
+                if (ret)
+                {
+                    strm->msg = (char*)"invalid distances set";
                     state->mode = BAD;
                     break;
                 }
+
                 Tracev((stderr, "inflate:       codes ok\n"));
                 state->mode = LEN;
 
             case LEN:
+
                 /* use inflate_fast() if we have enough input and output */
-            if (have >= 6 && left >= 258) {
+                if (have >= 6 && left >= 258)
+                {
                     RESTORE();
+
                     if (state->whave < state->wsize)
                         state->whave = state->wsize - left;
+
                     inflate_fast(strm, state->wsize);
                     LOAD();
                     break;
                 }
 
                 /* get a literal, length, or end-of-block code */
-            for (;;) {
+                for (;;)
+                {
                     here = state->lencode[BITS(state->lenbits)];
+
                     if ((unsigned)(here.bits) <= bits) break;
+
                     PULLBYTE();
                 }
-            if (here.op && (here.op & 0xf0) == 0) {
+
+                if (here.op && (here.op & 0xf0) == 0)
+                {
                     last = here;
-                for (;;) {
+
+                    for (;;)
+                    {
                         here = state->lencode[last.val +
                                               (BITS(last.bits + last.op) >> last.bits)];
+
                         if ((unsigned)(last.bits + here.bits) <= bits) break;
+
                         PULLBYTE();
                     }
+
                     DROPBITS(last.bits);
                 }
+
                 DROPBITS(here.bits);
                 state->length = (unsigned)here.val;
 
                 /* process literal */
-            if (here.op == 0) {
+                if (here.op == 0)
+                {
                     Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
                              "inflate:         literal '%c'\n" :
                              "inflate:         literal 0x%02x\n", here.val));
@@ -550,95 +636,133 @@ void FAR *out_desc;
                 }
 
                 /* process end of block */
-            if (here.op & 32) {
+                if (here.op & 32)
+                {
                     Tracevv((stderr, "inflate:         end of block\n"));
                     state->mode = TYPE;
                     break;
                 }
 
                 /* invalid code */
-            if (here.op & 64) {
-                strm->msg = (char *)"invalid literal/length code";
+                if (here.op & 64)
+                {
+                    strm->msg = (char*)"invalid literal/length code";
                     state->mode = BAD;
                     break;
                 }
 
                 /* length code -- get extra bits, if any */
                 state->extra = (unsigned)(here.op) & 15;
-            if (state->extra != 0) {
+
+                if (state->extra != 0)
+                {
                     NEEDBITS(state->extra);
                     state->length += BITS(state->extra);
                     DROPBITS(state->extra);
                 }
+
                 Tracevv((stderr, "inflate:         length %u\n", state->length));
 
                 /* get distance code */
-            for (;;) {
+                for (;;)
+                {
                     here = state->distcode[BITS(state->distbits)];
+
                     if ((unsigned)(here.bits) <= bits) break;
+
                     PULLBYTE();
                 }
-            if ((here.op & 0xf0) == 0) {
+
+                if ((here.op & 0xf0) == 0)
+                {
                     last = here;
-                for (;;) {
+
+                    for (;;)
+                    {
                         here = state->distcode[last.val +
                                                (BITS(last.bits + last.op) >> last.bits)];
+
                         if ((unsigned)(last.bits + here.bits) <= bits) break;
+
                         PULLBYTE();
                     }
+
                     DROPBITS(last.bits);
                 }
+
                 DROPBITS(here.bits);
-            if (here.op & 64) {
-                strm->msg = (char *)"invalid distance code";
+
+                if (here.op & 64)
+                {
+                    strm->msg = (char*)"invalid distance code";
                     state->mode = BAD;
                     break;
                 }
+
                 state->offset = (unsigned)here.val;
 
                 /* get distance extra bits, if any */
                 state->extra = (unsigned)(here.op) & 15;
-            if (state->extra != 0) {
+
+                if (state->extra != 0)
+                {
                     NEEDBITS(state->extra);
                     state->offset += BITS(state->extra);
                     DROPBITS(state->extra);
                 }
+
                 if (state->offset > state->wsize - (state->whave < state->wsize ?
-                                                left : 0)) {
-                strm->msg = (char *)"invalid distance too far back";
+                                                    left : 0))
+                {
+                    strm->msg = (char*)"invalid distance too far back";
                     state->mode = BAD;
                     break;
                 }
+
                 Tracevv((stderr, "inflate:         distance %u\n", state->offset));
 
                 /* copy match from window to output */
-            do {
+                do
+                {
                     ROOM();
                     copy = state->wsize - state->offset;
-                if (copy < left) {
+
+                    if (copy < left)
+                    {
                         from = put + copy;
                         copy = left - copy;
                     }
-                else {
+                    else
+                    {
                         from = put - state->offset;
                         copy = left;
                     }
+
                     if (copy > state->length) copy = state->length;
+
                     state->length -= copy;
                     left -= copy;
-                do {
+
+                    do
+                    {
                         *put++ = *from++;
-                } while (--copy);
-            } while (state->length != 0);
+                    }
+                    while (--copy);
+                }
+                while (state->length != 0);
+
                 break;
 
             case DONE:
                 /* inflate stream terminated properly -- write leftover output */
                 ret = Z_STREAM_END;
-            if (left < state->wsize) {
+
+                if (left < state->wsize)
+                {
                     if (out(out_desc, state->window, state->wsize - left))
                         ret = Z_BUF_ERROR;
                 }
+
                 goto inf_leave;
 
             case BAD:
@@ -651,7 +775,7 @@ void FAR *out_desc;
         }
 
     /* Return unused input */
-  inf_leave:
+inf_leave:
     strm->next_in = next;
     strm->avail_in = have;
     return ret;
@@ -666,6 +790,7 @@ z_streamp strm;
 {
     if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
         return Z_STREAM_ERROR;
+
     ZFREE(strm, strm->state);
     strm->state = Z_NULL;
     Tracev((stderr, "inflate: end\n"));

extern/zlib/inffast.c

@@ -72,23 +72,23 @@ z_streamp strm;
 unsigned start;         /* inflate()'s starting value for strm->avail_out */
 #endif
 {
-    struct inflate_state FAR *state;
-    unsigned char FAR *in;      /* local strm->next_in */
-    unsigned char FAR *last;    /* while in < last, enough input available */
-    unsigned char FAR *out;     /* local strm->next_out */
-    unsigned char FAR *beg;     /* inflate()'s initial strm->next_out */
-    unsigned char FAR *end;     /* while out < end, enough space available */
+    struct inflate_state FAR* state;
+    unsigned char FAR* in;      /* local strm->next_in */
+    unsigned char FAR* last;    /* while in < last, enough input available */
+    unsigned char FAR* out;     /* local strm->next_out */
+    unsigned char FAR* beg;     /* inflate()'s initial strm->next_out */
+    unsigned char FAR* end;     /* while out < end, enough space available */
 #ifdef INFLATE_STRICT
     unsigned dmax;              /* maximum distance from zlib header */
 #endif
     unsigned wsize;             /* window size or zero if not using window */
     unsigned whave;             /* valid bytes in the window */
     unsigned wnext;             /* window write index */
-    unsigned char FAR *window;  /* allocated sliding window, if wsize != 0 */
+    unsigned char FAR* window;  /* allocated sliding window, if wsize != 0 */
     unsigned long hold;         /* local strm->hold */
     unsigned bits;              /* local strm->bits */
-    code const FAR *lcode;      /* local strm->lencode */
-    code const FAR *dcode;      /* local strm->distcode */
+    code const FAR* lcode;      /* local strm->lencode */
+    code const FAR* dcode;      /* local strm->distcode */
     unsigned lmask;             /* mask for first level of length codes */
     unsigned dmask;             /* mask for first level of distance codes */
     code here;                  /* retrieved table entry */
@@ -96,10 +96,10 @@ unsigned start;         /* inflate()'s starting value for strm->avail_out */
     /*  window position, window bytes to copy */
     unsigned len;               /* match length, unused bytes */
     unsigned dist;              /* match distance */
-    unsigned char FAR *from;    /* where to copy match from */
+    unsigned char FAR* from;    /* where to copy match from */
 
     /* copy state to local variables */
-    state = (struct inflate_state FAR *)strm->state;
+    state = (struct inflate_state FAR*)strm->state;
     in = strm->next_in - OFF;
     last = in + (strm->avail_in - 5);
     out = strm->next_out - OFF;
@@ -121,194 +121,287 @@ unsigned start;         /* inflate()'s starting value for strm->avail_out */
 
     /* decode literals and length/distances until end-of-block or not enough
        input data or output space */
-    do {
-        if (bits < 15) {
+    do
+    {
+        if (bits < 15)
+        {
             hold += (unsigned long)(PUP(in)) << bits;
             bits += 8;
             hold += (unsigned long)(PUP(in)) << bits;
             bits += 8;
         }
+
         here = lcode[hold & lmask];
-      dolen:
+dolen:
         op = (unsigned)(here.bits);
         hold >>= op;
         bits -= op;
         op = (unsigned)(here.op);
-        if (op == 0) {                          /* literal */
+
+        if (op == 0)                            /* literal */
+        {
             Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
                      "inflate:         literal '%c'\n" :
                      "inflate:         literal 0x%02x\n", here.val));
             PUP(out) = (unsigned char)(here.val);
         }
-        else if (op & 16) {                     /* length base */
+        else if (op & 16)                       /* length base */
+        {
             len = (unsigned)(here.val);
             op &= 15;                           /* number of extra bits */
-            if (op) {
-                if (bits < op) {
+
+            if (op)
+            {
+                if (bits < op)
+                {
                     hold += (unsigned long)(PUP(in)) << bits;
                     bits += 8;
                 }
+
                 len += (unsigned)hold & ((1U << op) - 1);
                 hold >>= op;
                 bits -= op;
             }
+
             Tracevv((stderr, "inflate:         length %u\n", len));
-            if (bits < 15) {
+
+            if (bits < 15)
+            {
                 hold += (unsigned long)(PUP(in)) << bits;
                 bits += 8;
                 hold += (unsigned long)(PUP(in)) << bits;
                 bits += 8;
             }
+
             here = dcode[hold & dmask];
-          dodist:
+dodist:
             op = (unsigned)(here.bits);
             hold >>= op;
             bits -= op;
             op = (unsigned)(here.op);
-            if (op & 16) {                      /* distance base */
+
+            if (op & 16)                        /* distance base */
+            {
                 dist = (unsigned)(here.val);
                 op &= 15;                       /* number of extra bits */
-                if (bits < op) {
+
+                if (bits < op)
+                {
                     hold += (unsigned long)(PUP(in)) << bits;
                     bits += 8;
-                    if (bits < op) {
+
+                    if (bits < op)
+                    {
                         hold += (unsigned long)(PUP(in)) << bits;
                         bits += 8;
                     }
                 }
+
                 dist += (unsigned)hold & ((1U << op) - 1);
 #ifdef INFLATE_STRICT
-                if (dist > dmax) {
-                    strm->msg = (char *)"invalid distance too far back";
+
+                if (dist > dmax)
+                {
+                    strm->msg = (char*)"invalid distance too far back";
                     state->mode = BAD;
                     break;
                 }
+
 #endif
                 hold >>= op;
                 bits -= op;
                 Tracevv((stderr, "inflate:         distance %u\n", dist));
                 op = (unsigned)(out - beg);     /* max distance in output */
-                if (dist > op) {                /* see if copy from window */
+
+                if (dist > op)                  /* see if copy from window */
+                {
                     op = dist - op;             /* distance back in window */
-                    if (op > whave) {
-                        if (state->sane) {
+
+                    if (op > whave)
+                    {
+                        if (state->sane)
+                        {
                             strm->msg =
-                                (char *)"invalid distance too far back";
+                                (char*)"invalid distance too far back";
                             state->mode = BAD;
                             break;
                         }
+
 #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
-                        if (len <= op - whave) {
-                            do {
+
+                        if (len <= op - whave)
+                        {
+                            do
+                            {
                                 PUP(out) = 0;
-                            } while (--len);
+                            }
+                            while (--len);
+
                             continue;
                         }
+
                         len -= op - whave;
-                        do {
+
+                        do
+                        {
                             PUP(out) = 0;
-                        } while (--op > whave);
-                        if (op == 0) {
+                        }
+                        while (--op > whave);
+
+                        if (op == 0)
+                        {
                             from = out - dist;
-                            do {
+
+                            do
+                            {
                                 PUP(out) = PUP(from);
-                            } while (--len);
+                            }
+                            while (--len);
+
                             continue;
                         }
+
 #endif
                     }
+
                     from = window - OFF;
-                    if (wnext == 0) {           /* very common case */
+
+                    if (wnext == 0)             /* very common case */
+                    {
                         from += wsize - op;
-                        if (op < len) {         /* some from window */
+
+                        if (op < len)           /* some from window */
+                        {
                             len -= op;
-                            do {
+
+                            do
+                            {
                                 PUP(out) = PUP(from);
-                            } while (--op);
+                            }
+                            while (--op);
+
                             from = out - dist;  /* rest from output */
                         }
                     }
-                    else if (wnext < op) {      /* wrap around window */
+                    else if (wnext < op)        /* wrap around window */
+                    {
                         from += wsize + wnext - op;
                         op -= wnext;
-                        if (op < len) {         /* some from end of window */
+
+                        if (op < len)           /* some from end of window */
+                        {
                             len -= op;
-                            do {
+
+                            do
+                            {
                                 PUP(out) = PUP(from);
-                            } while (--op);
+                            }
+                            while (--op);
+
                             from = window - OFF;
-                            if (wnext < len) {  /* some from start of window */
+
+                            if (wnext < len)    /* some from start of window */
+                            {
                                 op = wnext;
                                 len -= op;
-                                do {
+
+                                do
+                                {
                                     PUP(out) = PUP(from);
-                                } while (--op);
+                                }
+                                while (--op);
+
                                 from = out - dist;      /* rest from output */
                             }
                         }
                     }
-                    else {                      /* contiguous in window */
+                    else                        /* contiguous in window */
+                    {
                         from += wnext - op;
-                        if (op < len) {         /* some from window */
+
+                        if (op < len)           /* some from window */
+                        {
                             len -= op;
-                            do {
+
+                            do
+                            {
                                 PUP(out) = PUP(from);
-                            } while (--op);
+                            }
+                            while (--op);
+
                             from = out - dist;  /* rest from output */
                         }
                     }
-                    while (len > 2) {
+
+                    while (len > 2)
+                    {
                         PUP(out) = PUP(from);
                         PUP(out) = PUP(from);
                         PUP(out) = PUP(from);
                         len -= 3;
                     }
-                    if (len) {
+
+                    if (len)
+                    {
                         PUP(out) = PUP(from);
+
                         if (len > 1)
                             PUP(out) = PUP(from);
                     }
                 }
-                else {
+                else
+                {
                     from = out - dist;          /* copy direct from output */
-                    do {                        /* minimum length is three */
+
+                    do                          /* minimum length is three */
+                    {
                         PUP(out) = PUP(from);
                         PUP(out) = PUP(from);
                         PUP(out) = PUP(from);
                         len -= 3;
-                    } while (len > 2);
-                    if (len) {
+                    }
+                    while (len > 2);
+
+                    if (len)
+                    {
                         PUP(out) = PUP(from);
+
                         if (len > 1)
                             PUP(out) = PUP(from);
                     }
                 }
             }
-            else if ((op & 64) == 0) {          /* 2nd level distance code */
+            else if ((op & 64) == 0)            /* 2nd level distance code */
+            {
                 here = dcode[here.val + (hold & ((1U << op) - 1))];
                 goto dodist;
             }
-            else {
-                strm->msg = (char *)"invalid distance code";
+            else
+            {
+                strm->msg = (char*)"invalid distance code";
                 state->mode = BAD;
                 break;
             }
         }
-        else if ((op & 64) == 0) {              /* 2nd level length code */
+        else if ((op & 64) == 0)                /* 2nd level length code */
+        {
             here = lcode[here.val + (hold & ((1U << op) - 1))];
             goto dolen;
         }
-        else if (op & 32) {                     /* end-of-block */
+        else if (op & 32)                       /* end-of-block */
+        {
             Tracevv((stderr, "inflate:         end of block\n"));
             state->mode = TYPE;
             break;
         }
-        else {
-            strm->msg = (char *)"invalid literal/length code";
+        else
+        {
+            strm->msg = (char*)"invalid literal/length code";
             state->mode = BAD;
             break;
         }
-    } while (in < last && out < end);
+    }
+    while (in < last && out < end);
 
     /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
     len = bits >> 3;

extern/zlib/inffixed.h

@@ -1,94 +1,96 @@
-    /* inffixed.h -- table for decoding fixed codes
+/* inffixed.h -- table for decoding fixed codes
  * Generated automatically by makefixed().
  */
 
-    /* WARNING: this file should *not* be used by applications.
+/* WARNING: this file should *not* be used by applications.
    It is part of the implementation of this library and is
    subject to change. Applications should only use zlib.h.
  */
 
-    static const code lenfix[512] = {
-        {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48},
-        {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128},
-        {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59},
-        {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176},
-        {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20},
-        {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100},
-        {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8},
-        {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216},
-        {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76},
-        {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114},
-        {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},
-        {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148},
-        {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42},
-        {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86},
-        {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15},
-        {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236},
-        {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62},
-        {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142},
-        {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31},
-        {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162},
-        {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25},
-        {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105},
-        {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4},
-        {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202},
-        {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69},
-        {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125},
-        {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13},
-        {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195},
-        {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35},
-        {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91},
-        {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19},
-        {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246},
-        {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55},
-        {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135},
-        {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99},
-        {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190},
-        {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16},
-        {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96},
-        {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6},
-        {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209},
-        {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},
-        {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116},
-        {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4},
-        {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153},
-        {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44},
-        {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82},
-        {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11},
-        {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
-        {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58},
-        {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138},
-        {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51},
-        {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173},
-        {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30},
-        {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110},
-        {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0},
-        {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195},
-        {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65},
-        {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121},
-        {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},
-        {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258},
-        {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37},
-        {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93},
-        {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23},
-        {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251},
-        {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51},
-        {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
-        {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67},
-        {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183},
-        {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23},
-        {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103},
-        {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9},
-        {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223},
-        {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79},
-        {0,9,255}
-    };
+static const code lenfix[512] =
+{
+    {96, 7, 0}, {0, 8, 80}, {0, 8, 16}, {20, 8, 115}, {18, 7, 31}, {0, 8, 112}, {0, 8, 48},
+    {0, 9, 192}, {16, 7, 10}, {0, 8, 96}, {0, 8, 32}, {0, 9, 160}, {0, 8, 0}, {0, 8, 128},
+    {0, 8, 64}, {0, 9, 224}, {16, 7, 6}, {0, 8, 88}, {0, 8, 24}, {0, 9, 144}, {19, 7, 59},
+    {0, 8, 120}, {0, 8, 56}, {0, 9, 208}, {17, 7, 17}, {0, 8, 104}, {0, 8, 40}, {0, 9, 176},
+    {0, 8, 8}, {0, 8, 136}, {0, 8, 72}, {0, 9, 240}, {16, 7, 4}, {0, 8, 84}, {0, 8, 20},
+    {21, 8, 227}, {19, 7, 43}, {0, 8, 116}, {0, 8, 52}, {0, 9, 200}, {17, 7, 13}, {0, 8, 100},
+    {0, 8, 36}, {0, 9, 168}, {0, 8, 4}, {0, 8, 132}, {0, 8, 68}, {0, 9, 232}, {16, 7, 8},
+    {0, 8, 92}, {0, 8, 28}, {0, 9, 152}, {20, 7, 83}, {0, 8, 124}, {0, 8, 60}, {0, 9, 216},
+    {18, 7, 23}, {0, 8, 108}, {0, 8, 44}, {0, 9, 184}, {0, 8, 12}, {0, 8, 140}, {0, 8, 76},
+    {0, 9, 248}, {16, 7, 3}, {0, 8, 82}, {0, 8, 18}, {21, 8, 163}, {19, 7, 35}, {0, 8, 114},
+    {0, 8, 50}, {0, 9, 196}, {17, 7, 11}, {0, 8, 98}, {0, 8, 34}, {0, 9, 164}, {0, 8, 2},
+    {0, 8, 130}, {0, 8, 66}, {0, 9, 228}, {16, 7, 7}, {0, 8, 90}, {0, 8, 26}, {0, 9, 148},
+    {20, 7, 67}, {0, 8, 122}, {0, 8, 58}, {0, 9, 212}, {18, 7, 19}, {0, 8, 106}, {0, 8, 42},
+    {0, 9, 180}, {0, 8, 10}, {0, 8, 138}, {0, 8, 74}, {0, 9, 244}, {16, 7, 5}, {0, 8, 86},
+    {0, 8, 22}, {64, 8, 0}, {19, 7, 51}, {0, 8, 118}, {0, 8, 54}, {0, 9, 204}, {17, 7, 15},
+    {0, 8, 102}, {0, 8, 38}, {0, 9, 172}, {0, 8, 6}, {0, 8, 134}, {0, 8, 70}, {0, 9, 236},
+    {16, 7, 9}, {0, 8, 94}, {0, 8, 30}, {0, 9, 156}, {20, 7, 99}, {0, 8, 126}, {0, 8, 62},
+    {0, 9, 220}, {18, 7, 27}, {0, 8, 110}, {0, 8, 46}, {0, 9, 188}, {0, 8, 14}, {0, 8, 142},
+    {0, 8, 78}, {0, 9, 252}, {96, 7, 0}, {0, 8, 81}, {0, 8, 17}, {21, 8, 131}, {18, 7, 31},
+    {0, 8, 113}, {0, 8, 49}, {0, 9, 194}, {16, 7, 10}, {0, 8, 97}, {0, 8, 33}, {0, 9, 162},
+    {0, 8, 1}, {0, 8, 129}, {0, 8, 65}, {0, 9, 226}, {16, 7, 6}, {0, 8, 89}, {0, 8, 25},
+    {0, 9, 146}, {19, 7, 59}, {0, 8, 121}, {0, 8, 57}, {0, 9, 210}, {17, 7, 17}, {0, 8, 105},
+    {0, 8, 41}, {0, 9, 178}, {0, 8, 9}, {0, 8, 137}, {0, 8, 73}, {0, 9, 242}, {16, 7, 4},
+    {0, 8, 85}, {0, 8, 21}, {16, 8, 258}, {19, 7, 43}, {0, 8, 117}, {0, 8, 53}, {0, 9, 202},
+    {17, 7, 13}, {0, 8, 101}, {0, 8, 37}, {0, 9, 170}, {0, 8, 5}, {0, 8, 133}, {0, 8, 69},
+    {0, 9, 234}, {16, 7, 8}, {0, 8, 93}, {0, 8, 29}, {0, 9, 154}, {20, 7, 83}, {0, 8, 125},
+    {0, 8, 61}, {0, 9, 218}, {18, 7, 23}, {0, 8, 109}, {0, 8, 45}, {0, 9, 186}, {0, 8, 13},
+    {0, 8, 141}, {0, 8, 77}, {0, 9, 250}, {16, 7, 3}, {0, 8, 83}, {0, 8, 19}, {21, 8, 195},
+    {19, 7, 35}, {0, 8, 115}, {0, 8, 51}, {0, 9, 198}, {17, 7, 11}, {0, 8, 99}, {0, 8, 35},
+    {0, 9, 166}, {0, 8, 3}, {0, 8, 131}, {0, 8, 67}, {0, 9, 230}, {16, 7, 7}, {0, 8, 91},
+    {0, 8, 27}, {0, 9, 150}, {20, 7, 67}, {0, 8, 123}, {0, 8, 59}, {0, 9, 214}, {18, 7, 19},
+    {0, 8, 107}, {0, 8, 43}, {0, 9, 182}, {0, 8, 11}, {0, 8, 139}, {0, 8, 75}, {0, 9, 246},
+    {16, 7, 5}, {0, 8, 87}, {0, 8, 23}, {64, 8, 0}, {19, 7, 51}, {0, 8, 119}, {0, 8, 55},
+    {0, 9, 206}, {17, 7, 15}, {0, 8, 103}, {0, 8, 39}, {0, 9, 174}, {0, 8, 7}, {0, 8, 135},
+    {0, 8, 71}, {0, 9, 238}, {16, 7, 9}, {0, 8, 95}, {0, 8, 31}, {0, 9, 158}, {20, 7, 99},
+    {0, 8, 127}, {0, 8, 63}, {0, 9, 222}, {18, 7, 27}, {0, 8, 111}, {0, 8, 47}, {0, 9, 190},
+    {0, 8, 15}, {0, 8, 143}, {0, 8, 79}, {0, 9, 254}, {96, 7, 0}, {0, 8, 80}, {0, 8, 16},
+    {20, 8, 115}, {18, 7, 31}, {0, 8, 112}, {0, 8, 48}, {0, 9, 193}, {16, 7, 10}, {0, 8, 96},
+    {0, 8, 32}, {0, 9, 161}, {0, 8, 0}, {0, 8, 128}, {0, 8, 64}, {0, 9, 225}, {16, 7, 6},
+    {0, 8, 88}, {0, 8, 24}, {0, 9, 145}, {19, 7, 59}, {0, 8, 120}, {0, 8, 56}, {0, 9, 209},
+    {17, 7, 17}, {0, 8, 104}, {0, 8, 40}, {0, 9, 177}, {0, 8, 8}, {0, 8, 136}, {0, 8, 72},
+    {0, 9, 241}, {16, 7, 4}, {0, 8, 84}, {0, 8, 20}, {21, 8, 227}, {19, 7, 43}, {0, 8, 116},
+    {0, 8, 52}, {0, 9, 201}, {17, 7, 13}, {0, 8, 100}, {0, 8, 36}, {0, 9, 169}, {0, 8, 4},
+    {0, 8, 132}, {0, 8, 68}, {0, 9, 233}, {16, 7, 8}, {0, 8, 92}, {0, 8, 28}, {0, 9, 153},
+    {20, 7, 83}, {0, 8, 124}, {0, 8, 60}, {0, 9, 217}, {18, 7, 23}, {0, 8, 108}, {0, 8, 44},
+    {0, 9, 185}, {0, 8, 12}, {0, 8, 140}, {0, 8, 76}, {0, 9, 249}, {16, 7, 3}, {0, 8, 82},
+    {0, 8, 18}, {21, 8, 163}, {19, 7, 35}, {0, 8, 114}, {0, 8, 50}, {0, 9, 197}, {17, 7, 11},
+    {0, 8, 98}, {0, 8, 34}, {0, 9, 165}, {0, 8, 2}, {0, 8, 130}, {0, 8, 66}, {0, 9, 229},
+    {16, 7, 7}, {0, 8, 90}, {0, 8, 26}, {0, 9, 149}, {20, 7, 67}, {0, 8, 122}, {0, 8, 58},
+    {0, 9, 213}, {18, 7, 19}, {0, 8, 106}, {0, 8, 42}, {0, 9, 181}, {0, 8, 10}, {0, 8, 138},
+    {0, 8, 74}, {0, 9, 245}, {16, 7, 5}, {0, 8, 86}, {0, 8, 22}, {64, 8, 0}, {19, 7, 51},
+    {0, 8, 118}, {0, 8, 54}, {0, 9, 205}, {17, 7, 15}, {0, 8, 102}, {0, 8, 38}, {0, 9, 173},
+    {0, 8, 6}, {0, 8, 134}, {0, 8, 70}, {0, 9, 237}, {16, 7, 9}, {0, 8, 94}, {0, 8, 30},
+    {0, 9, 157}, {20, 7, 99}, {0, 8, 126}, {0, 8, 62}, {0, 9, 221}, {18, 7, 27}, {0, 8, 110},
+    {0, 8, 46}, {0, 9, 189}, {0, 8, 14}, {0, 8, 142}, {0, 8, 78}, {0, 9, 253}, {96, 7, 0},
+    {0, 8, 81}, {0, 8, 17}, {21, 8, 131}, {18, 7, 31}, {0, 8, 113}, {0, 8, 49}, {0, 9, 195},
+    {16, 7, 10}, {0, 8, 97}, {0, 8, 33}, {0, 9, 163}, {0, 8, 1}, {0, 8, 129}, {0, 8, 65},
+    {0, 9, 227}, {16, 7, 6}, {0, 8, 89}, {0, 8, 25}, {0, 9, 147}, {19, 7, 59}, {0, 8, 121},
+    {0, 8, 57}, {0, 9, 211}, {17, 7, 17}, {0, 8, 105}, {0, 8, 41}, {0, 9, 179}, {0, 8, 9},
+    {0, 8, 137}, {0, 8, 73}, {0, 9, 243}, {16, 7, 4}, {0, 8, 85}, {0, 8, 21}, {16, 8, 258},
+    {19, 7, 43}, {0, 8, 117}, {0, 8, 53}, {0, 9, 203}, {17, 7, 13}, {0, 8, 101}, {0, 8, 37},
+    {0, 9, 171}, {0, 8, 5}, {0, 8, 133}, {0, 8, 69}, {0, 9, 235}, {16, 7, 8}, {0, 8, 93},
+    {0, 8, 29}, {0, 9, 155}, {20, 7, 83}, {0, 8, 125}, {0, 8, 61}, {0, 9, 219}, {18, 7, 23},
+    {0, 8, 109}, {0, 8, 45}, {0, 9, 187}, {0, 8, 13}, {0, 8, 141}, {0, 8, 77}, {0, 9, 251},
+    {16, 7, 3}, {0, 8, 83}, {0, 8, 19}, {21, 8, 195}, {19, 7, 35}, {0, 8, 115}, {0, 8, 51},
+    {0, 9, 199}, {17, 7, 11}, {0, 8, 99}, {0, 8, 35}, {0, 9, 167}, {0, 8, 3}, {0, 8, 131},
+    {0, 8, 67}, {0, 9, 231}, {16, 7, 7}, {0, 8, 91}, {0, 8, 27}, {0, 9, 151}, {20, 7, 67},
+    {0, 8, 123}, {0, 8, 59}, {0, 9, 215}, {18, 7, 19}, {0, 8, 107}, {0, 8, 43}, {0, 9, 183},
+    {0, 8, 11}, {0, 8, 139}, {0, 8, 75}, {0, 9, 247}, {16, 7, 5}, {0, 8, 87}, {0, 8, 23},
+    {64, 8, 0}, {19, 7, 51}, {0, 8, 119}, {0, 8, 55}, {0, 9, 207}, {17, 7, 15}, {0, 8, 103},
+    {0, 8, 39}, {0, 9, 175}, {0, 8, 7}, {0, 8, 135}, {0, 8, 71}, {0, 9, 239}, {16, 7, 9},
+    {0, 8, 95}, {0, 8, 31}, {0, 9, 159}, {20, 7, 99}, {0, 8, 127}, {0, 8, 63}, {0, 9, 223},
+    {18, 7, 27}, {0, 8, 111}, {0, 8, 47}, {0, 9, 191}, {0, 8, 15}, {0, 8, 143}, {0, 8, 79},
+    {0, 9, 255}
+};
 
-    static const code distfix[32] = {
-        {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025},
-        {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193},
-        {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385},
-        {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577},
-        {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073},
-        {22,5,193},{64,5,0}
-    };
+static const code distfix[32] =
+{
+    {16, 5, 1}, {23, 5, 257}, {19, 5, 17}, {27, 5, 4097}, {17, 5, 5}, {25, 5, 1025},
+    {21, 5, 65}, {29, 5, 16385}, {16, 5, 3}, {24, 5, 513}, {20, 5, 33}, {28, 5, 8193},
+    {18, 5, 9}, {26, 5, 2049}, {22, 5, 129}, {64, 5, 0}, {16, 5, 2}, {23, 5, 385},
+    {19, 5, 25}, {27, 5, 6145}, {17, 5, 7}, {25, 5, 1537}, {21, 5, 97}, {29, 5, 24577},
+    {16, 5, 4}, {24, 5, 769}, {20, 5, 49}, {28, 5, 12289}, {18, 5, 13}, {26, 5, 3073},
+    {22, 5, 193}, {64, 5, 0}
+};

extern/zlib/inflate.h

@@ -17,7 +17,8 @@
 #endif
 
 /* Possible inflate modes between inflate() calls */
-typedef enum {
+typedef enum
+{
     HEAD,       /* i: waiting for magic header */
     FLAGS,      /* i: waiting for method and flags (gzip) */
     TIME,       /* i: waiting for modification time (gzip) */
@@ -78,7 +79,8 @@ typedef enum {
  */
 
 /* state maintained between inflate() calls.  Approximately 10K bytes. */
-struct inflate_state {
+struct inflate_state
+{
     inflate_mode mode;          /* current inflate mode */
     int last;                   /* true if processing last block */
     int wrap;                   /* bit 0 true for zlib, bit 1 true for gzip */
@@ -93,7 +95,7 @@ struct inflate_state {
     unsigned wsize;             /* window size or zero if not using window */
     unsigned whave;             /* valid bytes in the window */
     unsigned wnext;             /* window write index */
-    unsigned char FAR *window;  /* allocated sliding window, if needed */
+    unsigned char FAR* window;  /* allocated sliding window, if needed */
     /* bit accumulator */
     unsigned long hold;         /* input bit accumulator */
     unsigned bits;              /* number of bits in "in" */
@@ -103,8 +105,8 @@ struct inflate_state {
     /* for table and code decoding */
     unsigned extra;             /* extra bits needed */
     /* fixed and dynamic code tables */
-    code const FAR *lencode;    /* starting table for length/literal codes */
-    code const FAR *distcode;   /* starting table for distance codes */
+    code const FAR* lencode;    /* starting table for length/literal codes */
+    code const FAR* distcode;   /* starting table for distance codes */
     unsigned lenbits;           /* index bits for lencode */
     unsigned distbits;          /* index bits for distcode */
     /* dynamic table building */
@@ -112,7 +114,7 @@ struct inflate_state {
     unsigned nlen;              /* number of length code lengths */
     unsigned ndist;             /* number of distance code lengths */
     unsigned have;              /* number of code lengths in lens[] */
-    code FAR *next;             /* next available space in codes[] */
+    code FAR* next;             /* next available space in codes[] */
     unsigned short lens[320];   /* temporary storage for code lengths */
     unsigned short work[288];   /* work area for code table building */
     code codes[ENOUGH];         /* space for code tables */