Merge branch 'master' into master

.ci/build-freebsd.sh

@@ -1,37 +0,0 @@
-#!/bin/sh -ex
-
-# Pull all the submodules except llvm
-# Note: Tried to use git submodule status, but it takes over 20 seconds
-# shellcheck disable=SC2046
-git submodule -q update --init --depth 1 $(awk '/path/ && !/llvm/ && !/SPIRV/ { print $3 }' .gitmodules)
-
-# Prefer newer Clang than in base system (see also .ci/install-freebsd.sh)
-# libc++ isn't in llvm* packages, so download manually
-fetch https://github.com/llvm/llvm-project/releases/download/llvmorg-16.0.1/llvm-project-16.0.1.src.tar.xz
-tar xf llvm*.tar.xz
-export CC=clang16 CXX=clang++16
-cmake -B libcxx_build -G Ninja -S llvm*/libcxx \
-      -DLLVM_CCACHE_BUILD=ON \
-      -DLIBCXX_INCLUDE_BENCHMARKS=OFF \
-      -DCMAKE_INSTALL_PREFIX:PATH=libcxx_prefix
-cmake --build libcxx_build
-cmake --install libcxx_build
-export CXXFLAGS="$CXXFLAGS -nostdinc++ -isystem$PWD/libcxx_prefix/include/c++/v1"
-export LDFLAGS="$LDFLAGS -nostdlib++ -L$PWD/libcxx_prefix/lib -l:libc++.a -lcxxrt"
-
-CONFIGURE_ARGS="
-	-DWITH_LLVM=ON
-	-DUSE_SDL=OFF
-	-DUSE_PRECOMPILED_HEADERS=OFF
-	-DUSE_NATIVE_INSTRUCTIONS=OFF
-	-DUSE_SYSTEM_FFMPEG=ON
-	-DUSE_SYSTEM_CURL=ON
-	-DUSE_SYSTEM_LIBPNG=ON
-"
-
-# shellcheck disable=SC2086
-cmake -B build -G Ninja $CONFIGURE_ARGS
-cmake --build build
-
-ccache --show-stats
-ccache --zero-stats

.ci/build-linux.sh

@@ -1,66 +0,0 @@
-#!/bin/sh -ex
-
-# Setup Qt variables
-export QT_BASE_DIR=/opt/qt"${QTVERMIN}"
-export PATH="$QT_BASE_DIR"/bin:"$PATH"
-export LD_LIBRARY_PATH="$QT_BASE_DIR"/lib/x86_64-linux-gnu:"$QT_BASE_DIR"/lib
-
-if [ -z "$CIRRUS_CI" ]; then
-   cd rpcs3 || exit 1
-fi
-
-# Pull all the submodules except llvm
-# Note: Tried to use git submodule status, but it takes over 20 seconds
-# shellcheck disable=SC2046
-git submodule -q update --init $(awk '/path/ && !/llvm/ && !/SPIRV/ { print $3 }' .gitmodules)
-
-mkdir build && cd build || exit 1
-
-if [ "$COMPILER" = "gcc" ]; then
-    # These are set in the dockerfile
-    export CC="${GCC_BINARY}"
-    export CXX="${GXX_BINARY}"
-    export LINKER=gold
-    # We need to set the following variables for LTO to link properly
-    export AR=/usr/bin/gcc-ar-"$GCCVER"
-    export RANLIB=/usr/bin/gcc-ranlib-"$GCCVER"
-    export CFLAGS="-fuse-linker-plugin"
-else
-    export CC="${CLANG_BINARY}"
-    export CXX="${CLANGXX_BINARY}"
-    export LINKER=lld
-    export AR=/usr/bin/llvm-ar-"$LLVMVER"
-    export RANLIB=/usr/bin/llvm-ranlib-"$LLVMVER"
-fi
-
-export CFLAGS="$CFLAGS -fuse-ld=${LINKER}"
-
-cmake ..                                               \
-    -DCMAKE_INSTALL_PREFIX=/usr                        \
-    -DUSE_NATIVE_INSTRUCTIONS=OFF                      \
-    -DUSE_PRECOMPILED_HEADERS=OFF                      \
-    -DCMAKE_C_FLAGS="$CFLAGS"                          \
-    -DCMAKE_CXX_FLAGS="$CFLAGS"                        \
-    -DCMAKE_AR="$AR"                                   \
-    -DCMAKE_RANLIB="$RANLIB"                           \
-    -DUSE_SYSTEM_CURL=ON                               \
-    -DUSE_SDL=ON                                       \
-    -DOpenGL_GL_PREFERENCE=LEGACY                      \
-    -DLLVM_DIR=/opt/llvm/lib/cmake/llvm                \
-    -DSTATIC_LINK_LLVM=ON                              \
-    -G Ninja
-
-ninja; build_status=$?;
-
-cd ..
-
-shellcheck .ci/*.sh
-
-# If it compiled succesfully let's deploy.
-# Azure and Cirrus publish PRs as artifacts only.
-{   [ "$CI_HAS_ARTIFACTS" = "true" ];
-} && SHOULD_DEPLOY="true" || SHOULD_DEPLOY="false"
-
-if [ "$build_status" -eq 0 ] && [ "$SHOULD_DEPLOY" = "true" ]; then
-    .ci/deploy-linux.sh
-fi

.ci/build-mac.sh

@@ -1,70 +0,0 @@
-#!/bin/sh -ex
-
-brew install -f --overwrite nasm ninja git p7zip create-dmg ccache pipenv
-
-#/usr/sbin/softwareupdate --install-rosetta --agree-to-license
-arch -x86_64 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
-arch -x86_64 /usr/local/homebrew/bin/brew update
-arch -x86_64 /usr/local/homebrew/bin/brew install -f --overwrite llvm@16 sdl2 glew cmake
-arch -x86_64 /usr/local/homebrew/bin/brew link -f llvm@16
-
-#export MACOSX_DEPLOYMENT_TARGET=12.0
-export CXX=clang++
-export CC=clang
-
-export BREW_PATH;
-BREW_PATH="$(brew --prefix)"
-export BREW_X64_PATH;
-BREW_X64_PATH="$("/usr/local/homebrew/bin/brew" --prefix)"
-export BREW_BIN="/usr/local/bin"
-export BREW_SBIN="/usr/local/sbin"
-export CMAKE_EXTRA_OPTS='-DLLVM_TARGETS_TO_BUILD=X86'
-
-export WORKDIR;
-WORKDIR="$(pwd)"
-
-# Get Qt
-git clone https://github.com/engnr/qt-downloader.git
-cd qt-downloader
-git checkout f52efee0f18668c6d6de2dec0234b8c4bc54c597
-"/opt/homebrew/bin/pipenv" run pip3 install py7zr requests semantic_version lxml
-"/opt/homebrew/bin/pipenv" run ./qt-downloader macos desktop 5.15.2 clang_64 --opensource
-cd ..
-
-export Qt5_DIR="$WORKDIR/qt-downloader/5.15.2/clang_64/lib/cmake/Qt5"
-export SDL2_DIR="$BREW_X64_PATH/opt/sdl2/lib/cmake/SDL2"
-
-export PATH="$BREW_X64_PATH/opt/llvm@16/bin:$WORKDIR/qt-downloader/5.15.2/clang_64/bin:$BREW_BIN:$BREW_SBIN:/usr/bin:/bin:/usr/sbin:/sbin:/opt/X11/bin:/Library/Apple/usr/bin:$PATH"
-export LDFLAGS="-L$BREW_X64_PATH/lib -Wl,-rpath,$BREW_X64_PATH/lib"
-export CPPFLAGS="-I$BREW_X64_PATH/include -msse -msse2 -mcx16 -no-pie"
-export LIBRARY_PATH="$BREW_X64_PATH/lib"
-export LD_LIBRARY_PATH="$BREW_X64_PATH/lib"
-
-git submodule update --init --recursive --depth 1
-
-# 3rdparty fixes
-sed -i '' "s/extern const double NSAppKitVersionNumber;/const double NSAppKitVersionNumber = 1343;/g" 3rdparty/hidapi/hidapi/mac/hid.c
-
-mkdir build && cd build || exit 1
-
-"$BREW_X64_PATH/bin/cmake" .. \
-    -DUSE_SDL=ON -DUSE_DISCORD_RPC=OFF -DUSE_VULKAN=ON -DUSE_ALSA=OFF -DUSE_PULSE=OFF -DUSE_AUDIOUNIT=ON \
-    -DLLVM_CCACHE_BUILD=OFF -DLLVM_BUILD_RUNTIME=OFF -DLLVM_BUILD_TOOLS=OFF \
-    -DLLVM_INCLUDE_DOCS=OFF -DLLVM_INCLUDE_EXAMPLES=OFF -DLLVM_INCLUDE_TESTS=OFF -DLLVM_INCLUDE_TOOLS=OFF \
-    -DLLVM_INCLUDE_UTILS=OFF -DLLVM_USE_PERF=OFF -DLLVM_ENABLE_Z3_SOLVER=OFF \
-    -DUSE_NATIVE_INSTRUCTIONS=OFF \
-    -DUSE_SYSTEM_MVK=OFF \
-    $CMAKE_EXTRA_OPTS \
-    -DLLVM_TARGET_ARCH=X86_64 -DCMAKE_OSX_ARCHITECTURES=x86_64 -DCMAKE_IGNORE_PATH="$BREW_PATH/lib" \
-    -G Ninja
-
-"$BREW_PATH/bin/ninja"; build_status=$?;
-
-cd ..
-
-{   [ "$CI_HAS_ARTIFACTS" = "true" ];
-} && SHOULD_DEPLOY="true" || SHOULD_DEPLOY="false"
-
-if [ "$build_status" -eq 0 ] && [ "$SHOULD_DEPLOY" = "true" ]; then
-    .ci/deploy-mac.sh
-fi

.ci/deploy-linux.sh

@@ -1,43 +0,0 @@
-#!/bin/sh -ex
-
-cd build || exit 1
-
-if [ "$DEPLOY_APPIMAGE" = "true" ]; then
-    DESTDIR=AppDir ninja install
-
-    curl -sL -o /usr/bin/linuxdeploy https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage
-    chmod +x /usr/bin/linuxdeploy
-    curl -sL -o /usr/bin/linuxdeploy-plugin-qt https://github.com/linuxdeploy/linuxdeploy-plugin-qt/releases/download/continuous/linuxdeploy-plugin-qt-x86_64.AppImage
-    chmod +x /usr/bin/linuxdeploy-plugin-qt
-    curl -sL -o linuxdeploy-plugin-checkrt.sh https://github.com/linuxdeploy/linuxdeploy-plugin-checkrt/releases/download/continuous/linuxdeploy-plugin-checkrt-x86_64.sh
-    chmod +x ./linuxdeploy-plugin-checkrt.sh
-
-    EXTRA_QT_PLUGINS="svg;" APPIMAGE_EXTRACT_AND_RUN=1 linuxdeploy --appdir AppDir --plugin qt
-
-    # Remove libwayland-client because it has platform-dependent exports and breaks other OSes
-    rm -f ./AppDir/usr/lib/libwayland-client.so*
-
-    # Remove git directory containing local commit history file
-    rm -rf ./AppDir/usr/share/rpcs3/git
-
-    ./linuxdeploy-plugin-checkrt.sh --appdir AppDir
-
-    linuxdeploy --appimage-extract
-    ./squashfs-root/plugins/linuxdeploy-plugin-appimage/usr/bin/appimagetool AppDir -g
-
-    COMM_TAG=$(awk '/version{.*}/ { printf("%d.%d.%d", $5, $6, $7) }' ../rpcs3/rpcs3_version.cpp)
-    COMM_COUNT="$(git rev-list --count HEAD)"
-    COMM_HASH="$(git rev-parse --short=8 HEAD)"
-    RPCS3_APPIMAGE="rpcs3-v${COMM_TAG}-${COMM_COUNT}-${COMM_HASH}_linux64.AppImage"
-
-    mv ./RPCS3*.AppImage "$RPCS3_APPIMAGE"
-
-    # If we're building using a CI, let's copy over the AppImage artifact
-    if [ -n "$BUILD_ARTIFACTSTAGINGDIRECTORY" ]; then
-        cp "$RPCS3_APPIMAGE" "$ARTDIR"
-    fi
-
-    FILESIZE=$(stat -c %s ./rpcs3*.AppImage)
-    SHA256SUM=$(sha256sum ./rpcs3*.AppImage | awk '{ print $1 }')
-    echo "${SHA256SUM};${FILESIZE}B" > "$RELEASE_MESSAGE"
-fi

.ci/deploy-mac.sh

@@ -1,59 +0,0 @@
-#!/bin/sh -ex
-
-cd build || exit 1
-
-# Gather explicit version number and number of commits
-COMM_TAG=$(awk '/version{.*}/ { printf("%d.%d.%d", $5, $6, $7) }' ../rpcs3/rpcs3_version.cpp)
-COMM_COUNT=$(git rev-list --count HEAD)
-COMM_HASH=$(git rev-parse --short=8 HEAD)
-
-AVVER="${COMM_TAG}-${COMM_COUNT}"
-
-# AVVER is used for GitHub releases, it is the version number.
-echo "AVVER=$AVVER" >> ../.ci/ci-vars.env
-
-cd bin
-mkdir "rpcs3.app/Contents/lib/"
-
-cp "/usr/local/Homebrew/opt/llvm@16/lib/c++/libc++abi.1.0.dylib" "rpcs3.app/Contents/lib/libc++abi.1.dylib"
-
-rm -rf "rpcs3.app/Contents/Frameworks/QtPdf.framework" \
-"rpcs3.app/Contents/Frameworks/QtQml.framework" \
-"rpcs3.app/Contents/Frameworks/QtQmlModels.framework" \
-"rpcs3.app/Contents/Frameworks/QtQuick.framework" \
-"rpcs3.app/Contents/Frameworks/QtVirtualKeyboard.framework" \
-"rpcs3.app/Contents/Plugins/platforminputcontexts" \
-"rpcs3.app/Contents/Plugins/virtualkeyboard" \
-"rpcs3.app/Contents/Resources/git"
-
-# Need to do this rename hack due to case insensitive filesystem
-mv rpcs3.app RPCS3_.app
-mv RPCS3_.app RPCS3.app
-
-echo "[InternetShortcut]" > Quickstart.url
-echo "URL=https://rpcs3.net/quickstart" >> Quickstart.url
-echo "IconIndex=0" >> Quickstart.url
-
-DMG_FILEPATH="$BUILD_ARTIFACTSTAGINGDIRECTORY/rpcs3-v${COMM_TAG}-${COMM_COUNT}-${COMM_HASH}_macos.dmg"
-
-/opt/homebrew/bin/create-dmg --volname RPCS3 \
---window-size 800 400 \
---icon-size 100 \
---icon rpcs3.app 200 190 \
---add-file Quickstart.url Quickstart.url 400 20 \
---hide-extension rpcs3.app \
---hide-extension Quickstart.url \
---app-drop-link 600 185 \
---skip-jenkins \
-"$DMG_FILEPATH" \
-RPCS3.app
-
-/opt/homebrew/bin/7z a -mx9 rpcs3-v"${COMM_TAG}"-"${COMM_COUNT}"-"${COMM_HASH}"_macos.7z RPCS3.app
-
-FILESIZE=$(stat -f %z "$DMG_FILEPATH")
-SHA256SUM=$(shasum -a 256 "$DMG_FILEPATH" | awk '{ print $1 }')
-cd ..
-echo "${SHA256SUM};${FILESIZE}B" > "$RELEASE_MESSAGE"
-cd bin
-
-mv ./rpcs3*_macos.7z "$ARTDIR"

.ci/deploy-windows.sh

@@ -1,25 +0,0 @@
-#!/bin/sh -ex
-
-# BUILD_blablabla is Azure specific, so we wrap it for portability
-ARTIFACT_DIR="$BUILD_ARTIFACTSTAGINGDIRECTORY"
-
-# Remove unecessary files
-rm -f ./bin/rpcs3.exp ./bin/rpcs3.lib ./bin/rpcs3.pdb ./bin/vc_redist.x64.exe
-rm -rf ./bin/git
-
-# Prepare compatibility database for packaging, as well as
-# certificate for ssl (auto-updater)
-curl -sL 'https://rpcs3.net/compatibility?api=v1&export' | iconv -t UTF-8 > ./bin/GuiConfigs/compat_database.dat
-curl -sL 'https://curl.haxx.se/ca/cacert.pem' > ./bin/cacert.pem
-
-# Package artifacts
-7z a -m0=LZMA2 -mx9 "$BUILD" ./bin/*
-
-# Generate sha256 hashes
-# Write to file for GitHub releases
-sha256sum "$BUILD" | awk '{ print $1 }' | tee "$BUILD.sha256"
-echo "$(cat "$BUILD.sha256");$(stat -c %s "$BUILD")B" > GitHubReleaseMessage.txt
-
-# Move files to publishing directory
-cp -- "$BUILD" "$ARTIFACT_DIR"
-cp -- "$BUILD.sha256" "$ARTIFACT_DIR"

.ci/docker.env

@@ -1,15 +0,0 @@
-# Variables set by Azure Pipelines
-CI_HAS_ARTIFACTS
-BUILD_REASON
-BUILD_SOURCEVERSION
-BUILD_ARTIFACTSTAGINGDIRECTORY
-BUILD_REPOSITORY_NAME
-BUILD_SOURCEBRANCHNAME
-APPDIR
-ARTDIR
-RELEASE_MESSAGE
-# Variables for build matrix
-COMPILER
-DEPLOY_APPIMAGE
-# Private variables
-GITHUB_TOKEN

.ci/export-azure-vars.sh

@@ -1,13 +0,0 @@
-#!/bin/sh -e
-
-# Export variables for later stages of the Azure pipeline
-# Values done in this manner will appear as environment variables
-# in later stages.
-
-# From pure-sh-bible
-# Setting 'IFS' tells 'read' where to split the string.
-while IFS='=' read -r key val; do
-    # Skip over lines containing comments.
-    [ "${key##\#*}" ] || continue
-    echo "##vso[task.setvariable variable=$key]$val"
-done < ".ci/ci-vars.env"

.ci/export-cirrus-vars.sh

@@ -1,13 +0,0 @@
-#!/bin/sh -e
-
-# Export variables for later stages of the Cirrus pipeline
-# Values done in this manner will appear as environment variables
-# in later stages.
-
-# From pure-sh-bible
-# Setting 'IFS' tells 'read' where to split the string.
-while IFS='=' read -r key val; do
-    # Skip over lines containing comments.
-    [ "${key##\#*}" ] || continue
-    export "$key"="$val"
-done < ".ci/ci-vars.env"

.ci/get_keys-windows.sh

@@ -1,4 +0,0 @@
-#!/bin/sh -ex
-
-curl -L -o "./llvm.lock" "https://github.com/RPCS3/llvm-mirror/releases/download/custom-build-win-16.0.1/llvmlibs_mt.7z.sha256"
-curl -L -o "./glslang.lock" "https://github.com/RPCS3/glslang/releases/download/custom-build-win/glslanglibs_mt.7z.sha256"

.ci/github-upload.sh

@@ -1,42 +0,0 @@
-#!/bin/sh -ex
-
-ARTIFACT_DIR="$BUILD_ARTIFACTSTAGINGDIRECTORY"
-generate_post_data()
-{
-    body=$(cat GitHubReleaseMessage.txt)
-    cat <<EOF
-    {
-    "tag_name": "build-${BUILD_SOURCEVERSION}",
-    "target_commitish": "${UPLOAD_COMMIT_HASH}",
-    "name": "${AVVER}",
-    "body": "$body",
-    "draft": false,
-    "prerelease": false
-    }
-EOF
-}
-
-curl -s \
-    -H "Authorization: token ${RPCS3_TOKEN}" \
-    -H "Accept: application/vnd.github.v3+json" \
-    --data "$(generate_post_data)" "https://api.github.com/repos/$UPLOAD_REPO_FULL_NAME/releases" >> release.json
-
-cat release.json
-id=$(grep '"id"' release.json | cut -d ':' -f2 | head -n1 | awk '{$1=$1;print}')
-id=${id%?}
-echo "${id:?}"
-
-upload_file()
-{
-    curl -s \
-        -H "Authorization: token ${RPCS3_TOKEN}" \
-        -H "Accept: application/vnd.github.v3+json" \
-        -H "Content-Type: application/octet-stream" \
-        --data-binary @"$2"/"$3" \
-        "https://uploads.github.com/repos/$UPLOAD_REPO_FULL_NAME/releases/$1/assets?name=$3"
-}
-
-for file in "$ARTIFACT_DIR"/*; do
-    name=$(basename "$file")
-    upload_file "$id" "$ARTIFACT_DIR" "$name"
-done

.ci/install-freebsd.sh

@@ -1,18 +0,0 @@
-#!/usr/bin/env -S su -m root -ex
-# NOTE: this script is run under root permissions
-# shellcheck shell=sh disable=SC2096
-
-# RPCS3 often needs recent Qt5 and Vulkan-Headers
-sed -i '' 's/quarterly/latest/' /etc/pkg/FreeBSD.conf
-
-export ASSUME_ALWAYS_YES=true
-pkg info # debug
-
-# Prefer newer Clang than in base system (see also .ci/build-freebsd.sh)
-pkg install llvm16
-
-# Mandatory dependencies (qt5-dbus and qt5-gui are pulled via qt5-widgets)
-pkg install git ccache cmake ninja qt5-qmake qt5-buildtools qt5-widgets qt5-concurrent qt5-multimedia qt5-svg glew openal-soft ffmpeg
-
-# Optional dependencies (libevdev is pulled by qt5-gui)
-pkg install pkgconf alsa-lib pulseaudio sdl2 evdev-proto vulkan-headers vulkan-loader

.ci/setup-windows.sh

@@ -1,119 +0,0 @@
-#!/bin/sh -ex
-
-# These are Azure specific, so we wrap them for portability
-REPO_NAME="$BUILD_REPOSITORY_NAME"
-REPO_BRANCH="$SYSTEM_PULLREQUEST_SOURCEBRANCH"
-PR_NUMBER="$SYSTEM_PULLREQUEST_PULLREQUESTID"
-
-# Resource/dependency URLs
-# Qt mirrors can be volatile and slow, so we list 2
-#QT_HOST="http://mirrors.ocf.berkeley.edu/qt/"
-QT_HOST="http://qt.mirror.constant.com/"
-QT_URL_VER=$(echo "$QT_VER" | sed "s/\.//g")
-QT_VER_MSVC_UP=$(echo "${QT_VER_MSVC}" | tr '[:lower:]' '[:upper:]')
-QT_PREFIX="online/qtsdkrepository/windows_x86/desktop/qt${QT_VER_MAIN}_${QT_URL_VER}/qt.qt${QT_VER_MAIN}.${QT_URL_VER}.win64_${QT_VER_MSVC}_64/${QT_VER}-0-${QT_DATE}"
-QT_SUFFIX="-Windows-Windows_10-${QT_VER_MSVC_UP}-Windows-Windows_10-X86_64.7z"
-QT_BASE_URL="${QT_HOST}${QT_PREFIX}qtbase${QT_SUFFIX}"
-QT_WINE_URL="${QT_HOST}${QT_PREFIX}qtwinextras${QT_SUFFIX}"
-QT_DECL_URL="${QT_HOST}${QT_PREFIX}qtdeclarative${QT_SUFFIX}"
-QT_TOOL_URL="${QT_HOST}${QT_PREFIX}qttools${QT_SUFFIX}"
-QT_MM_URL="${QT_HOST}${QT_PREFIX}qtmultimedia${QT_SUFFIX}"
-QT_SVG_URL="${QT_HOST}${QT_PREFIX}qtsvg${QT_SUFFIX}"
-LLVMLIBS_URL='https://github.com/RPCS3/llvm-mirror/releases/download/custom-build-win-16.0.1/llvmlibs_mt.7z'
-GLSLANG_URL='https://github.com/RPCS3/glslang/releases/download/custom-build-win/glslanglibs_mt.7z'
-VULKAN_SDK_URL="https://www.dropbox.com/s/cs77c3iv5mbo0bt/VulkanSDK-${VULKAN_VER}-Installer.exe"
-
-DEP_URLS="         \
-    $QT_BASE_URL   \
-    $QT_WINE_URL   \
-    $QT_DECL_URL   \
-    $QT_TOOL_URL   \
-    $QT_MM_URL     \
-    $QT_SVG_URL    \
-    $LLVMLIBS_URL  \
-    $GLSLANG_URL   \
-    $VULKAN_SDK_URL"
-
-# Azure pipelines doesn't make a cache dir if it doesn't exist, so we do it manually
-[ -d "$CACHE_DIR" ] || mkdir "$CACHE_DIR"
-
-# Pull all the submodules except llvm, since it is built separately and we just download that build
-# Note: Tried to use git submodule status, but it takes over 20 seconds
-# shellcheck disable=SC2046
-git submodule -q update --init --depth=1 --jobs=8 $(awk '/path/ && !/llvm/ && !/SPIRV/ { print $3 }' .gitmodules)
-
-# Git bash doesn't have rev, so here it is
-rev()
-{
-    echo "$1" | awk '{ for(i = length($0); i != 0; --i) { a = a substr($0, i, 1); } } END { print a }'
-}
-
-# Usage: download_and_verify url checksum algo file
-# Check to see if a file is already cached, and the checksum matches. If not, download it.
-# Tries up to 3 times
-download_and_verify()
-{
-    url="$1"
-    correctChecksum="$2"
-    algo="$3"
-    fileName="$4"
-
-    for _ in 1 2 3; do
-        [ -e "$CACHE_DIR/$fileName" ] || curl -L -o "$CACHE_DIR/$fileName" "$url"
-        fileChecksum=$("${algo}sum" "$CACHE_DIR/$fileName" | awk '{ print $1 }')
-        [ "$fileChecksum" = "$correctChecksum" ] && return 0
-        rm "$CACHE_DIR/$fileName"
-    done
-
-    return 1;
-}
-
-# Some dependencies install here
-[ -d "./lib" ] || mkdir "./lib"
-
-for url in $DEP_URLS; do
-    # Get the filename from the URL. Breaks if urls have js args, so don't do that pls
-    fileName="$(rev "$(rev "$url" | cut -d'/' -f1)")"
-    [ -z "$fileName" ] && echo "Unable to parse url: $url" && exit 1
-
-    # shellcheck disable=SC1003
-    case "$url" in
-    *qt*) checksum=$(curl -L "${url}.sha1"); algo="sha1"; outDir='C:\Qt\' ;;
-    *llvm*) checksum=$(curl -L "${url}.sha256"); algo="sha256"; outDir="./3rdparty/llvm" ;;
-    *glslang*) checksum=$(curl -L "${url}.sha256"); algo="sha256"; outDir="./lib/Release-x64" ;;
-    *Vulkan*)
-        # Vulkan setup needs to be run in batch environment
-        # Need to subshell this or else it doesn't wait
-        download_and_verify "$url" "$VULKAN_SDK_SHA" "sha256" "$fileName"
-        cp "$CACHE_DIR/$fileName" .
-        _=$(echo "$fileName --accept-licenses --default-answer --confirm-command install" | cmd)
-        continue
-    ;;
-    *) echo "Unknown url resource: $url"; exit 1 ;;
-    esac
-
-    download_and_verify "$url" "$checksum" "$algo" "$fileName"
-    7z x -y "$CACHE_DIR/$fileName" -aos -o"$outDir"
-done
-
-# Gather explicit version number and number of commits
-COMM_TAG=$(awk '/version{.*}/ { printf("%d.%d.%d", $5, $6, $7) }' ./rpcs3/rpcs3_version.cpp)
-COMM_COUNT=$(git rev-list --count HEAD)
-COMM_HASH=$(git rev-parse --short=8 HEAD)
-
-# Format the above into filenames
-if [ -n "$PR_NUMBER" ]; then
-    AVVER="${COMM_TAG}-${COMM_HASH}"
-    BUILD="rpcs3-v${AVVER}_win64.7z"
-else
-    AVVER="${COMM_TAG}-${COMM_COUNT}"
-    BUILD="rpcs3-v${AVVER}-${COMM_HASH}_win64.7z"
-fi
-
-# BRANCH is used for experimental build warnings for pr builds, used in main_window.cpp.
-# BUILD is the name of the release artifact
-# AVVER is used for GitHub releases, it is the version number.
-BRANCH="${REPO_NAME}/${REPO_BRANCH}"
-echo "BRANCH=$BRANCH" > .ci/ci-vars.env
-echo "BUILD=$BUILD" >> .ci/ci-vars.env
-echo "AVVER=$AVVER" >> .ci/ci-vars.env

.cirrus.yml

@@ -1,151 +0,0 @@
-env:
-  CIRRUS_CLONE_DEPTH: 0 # Unshallow clone to obtain proper GIT_VERSION
-  BUILD_REPOSITORY_NAME: $CIRRUS_REPO_FULL_NAME
-  SYSTEM_PULLREQUEST_SOURCEBRANCH: $CIRRUS_BRANCH
-  SYSTEM_PULLREQUEST_PULLREQUESTID: $CIRRUS_PR
-  BUILD_SOURCEVERSION: $CIRRUS_CHANGE_IN_REPO
-  BUILD_SOURCEBRANCHNAME: $CIRRUS_BRANCH
-  RPCS3_TOKEN: ENCRYPTED[!a4c3850e29ab150692286a74bec29819d25971a7ec431b86de2a35f7ed90c5b2ab3c93469f9298e30924d843599110e9!]
-
-windows_task:
-  matrix:
-    - name: Cirrus Windows
-      windows_container:
-        image: cirrusci/windowsservercore:visualstudio2019
-        cpu: 8
-        memory: 16G
-  env:
-    CIRRUS_SHELL: "bash"
-    COMPILER: msvc
-    QT_VER_MAIN: '5'
-    BUILD_ARTIFACTSTAGINGDIRECTORY: ${CIRRUS_WORKING_DIR}\artifacts\
-    QT_VER: '5.15.2'
-    QT_VER_MSVC: 'msvc2019'
-    QT_DATE: '202011130602'
-    QTDIR: C:\Qt\${QT_VER}\${QT_VER_MSVC}_64
-    VULKAN_VER: '1.3.224.1'
-    VULKAN_SDK_SHA: '2029e652e39ee6a6036cff3765da31e1e6c595fd2413d3cd111dfab7855621ea'
-    VULKAN_SDK: C:\VulkanSDK\${VULKAN_VER}
-    CACHE_DIR: "./cache"
-    UPLOAD_COMMIT_HASH: 7d09e3be30805911226241afbb14f8cdc2eb054e
-    UPLOAD_REPO_FULL_NAME: "rpcs3/rpcs3-binaries-win"
-  deps_cache:
-    folder: "./cache"
-  #obj_cache:
-  #  folder: "./tmp"
-  #obj2_cache:
-  #  folder: "./rpcs3/x64"
-  setup_script:
-    - './.ci/get_keys-windows.sh'
-    - './.ci/setup-windows.sh'
-#   - choco install -y python # Needed for SPIRV, use either this or make a new Docker image
-#  spirv_script:
-#   - export PATH=${PATH}:"C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\MSBuild\Current\Bin"
-#   - cd "${CIRRUS_WORKING_DIR}/3rdparty/SPIRV"
-#   - msbuild.exe spirv.vcxproj //p:Configuration=Release //m
-  rpcs3_script:
-    - export PATH=${PATH}:"C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\MSBuild\Current\Bin"
-    - msbuild.exe rpcs3.sln //p:Configuration=Release //m
-  deploy_script:
-    - mkdir artifacts
-    - source './.ci/export-cirrus-vars.sh'
-    - './.ci/deploy-windows.sh'
-  artifacts:
-    name: Artifact
-    path: "*.7z*"
-  push_script: |
-    if [ "$CIRRUS_REPO_OWNER" = "RPCS3" ] && [ -z "$CIRRUS_PR" ] && [ "$CIRRUS_BRANCH" = "master" ]; then
-      source './.ci/export-cirrus-vars.sh'
-      './.ci/github-upload.sh'
-    fi;
-
-linux_task:
-  container:
-    image: rpcs3/rpcs3-ci-bionic:1.8
-    cpu: 4
-    memory: 16G
-  env:
-    BUILD_ARTIFACTSTAGINGDIRECTORY: ${CIRRUS_WORKING_DIR}/artifacts
-    ARTDIR: ${CIRRUS_WORKING_DIR}/artifacts/
-    CCACHE_DIR: "/tmp/ccache_dir"
-    CCACHE_MAXSIZE: 300M
-    CI_HAS_ARTIFACTS: true
-    UPLOAD_COMMIT_HASH: d812f1254a1157c80fd402f94446310560f54e5f
-    UPLOAD_REPO_FULL_NAME: "rpcs3/rpcs3-binaries-linux"
-    DEPLOY_APPIMAGE: true
-    APPDIR: "./appdir"
-    RELEASE_MESSAGE: "../GitHubReleaseMessage.txt"
-  ccache_cache:
-    folder: "/tmp/ccache_dir"
-  matrix:
-    - name: Cirrus Linux GCC
-      env:
-        COMPILER: gcc
-      gcc_script:
-        - mkdir artifacts
-        - ".ci/build-linux.sh"
-    - name: Cirrus Linux Clang
-      env:
-        COMPILER: clang
-      clang_script:
-        - mkdir artifacts
-        - ".ci/build-linux.sh"
-  artifacts:
-    name: Artifact
-    path: "artifacts/*"
-  push_script: |
-    if [ "$CIRRUS_REPO_OWNER" = "RPCS3" ] && [ -z "$CIRRUS_PR" ] && [ "$CIRRUS_BRANCH" = "master" ] && [ "$COMPILER" = "gcc" ]; then
-      COMM_TAG=$(awk '/version{.*}/ { printf("%d.%d.%d", $5, $6, $7) }' ./rpcs3/rpcs3_version.cpp)
-      COMM_COUNT=$(git rev-list --count HEAD)
-      COMM_HASH=$(git rev-parse --short=8 HEAD)
-
-      export AVVER="${COMM_TAG}-${COMM_COUNT}"
-
-      .ci/github-upload.sh
-    fi;
-
-freebsd_task:
-  matrix:
-    - name: Cirrus FreeBSD
-      freebsd_instance:
-        image_family: freebsd-13-1
-        cpu: 8
-        memory: 8G
-  env:
-    CCACHE_MAXSIZE: 300M # 3x clean build, rounded
-    CCACHE_DIR: /tmp/ccache_dir
-  ccache_cache:
-    folder: /tmp/ccache_dir
-  install_script: "sh -ex ./.ci/install-freebsd.sh"
-  script: "./.ci/build-freebsd.sh"
-
-macos_task:
-  timeout_in: 12000m
-  ccache_cache:
-    folder: /tmp/ccache_dir
-  matrix:
-    - name: Cirrus macOS
-      macos_instance:
-        image: ghcr.io/cirruslabs/macos-monterey-xcode:14
-      mac_script:
-        - mkdir artifacts
-        - chmod +x ".ci/build-mac.sh"
-        - chmod +x ".ci/deploy-mac.sh"
-        - ".ci/build-mac.sh"
-  env:
-    BUILD_ARTIFACTSTAGINGDIRECTORY: ${CIRRUS_WORKING_DIR}/artifacts
-    ARTDIR: ${CIRRUS_WORKING_DIR}/artifacts/
-    CCACHE_DIR: "/tmp/ccache_dir"
-    CCACHE_MAXSIZE: 300M
-    CI_HAS_ARTIFACTS: true
-    UPLOAD_COMMIT_HASH: 51ae32f468089a8169aaf1567de355ff4a3e0842
-    UPLOAD_REPO_FULL_NAME: "rpcs3/rpcs3-binaries-mac"
-    RELEASE_MESSAGE: "../GitHubReleaseMessage.txt"
-  artifacts:
-    name: Artifact
-    path: "artifacts/*"
-  push_script: |
-    if [ "$CIRRUS_REPO_OWNER" = "RPCS3" ] && [ -z "$CIRRUS_PR" ] && [ "$CIRRUS_BRANCH" = "master" ]; then
-      source './.ci/export-cirrus-vars.sh'
-      .ci/github-upload.sh
-    fi;

.clang-format

@@ -1,27 +1,26 @@
-Standard: c++20
-UseTab: AlignWithSpaces
-TabWidth: 4
-IndentWidth: 4
-AccessModifierOffset: -4
+Standard: Cpp11
+UseTab: ForIndentation
+TabWidth: 1
+IndentWidth: 1
+AccessModifierOffset: -1
 PointerAlignment: Left
 NamespaceIndentation: All
-ColumnLimit: 0
+ColumnLimit: 200
 BreakBeforeBraces: Allman
-BreakConstructorInitializers: BeforeColon
-BreakBeforeBinaryOperators: None
+BreakConstructorInitializersBeforeComma: true
+BreakBeforeBinaryOperators: false
 BreakBeforeTernaryOperators: false
-AlwaysBreakTemplateDeclarations: Yes
-AllowShortIfStatementsOnASingleLine: Never
-AllowShortBlocksOnASingleLine: Never
+AlwaysBreakTemplateDeclarations: true
+AllowShortIfStatementsOnASingleLine: true
+AllowShortBlocksOnASingleLine: true
 AllowShortCaseLabelsOnASingleLine: true
-AllowShortFunctionsOnASingleLine: Empty
-AllowShortLoopsOnASingleLine: false
-AllowShortLambdasOnASingleLine: Empty
+AllowShortFunctionsOnASingleLine: false
+AllowShortLoopsOnASingleLine: true
 Cpp11BracedListStyle: true
 IndentCaseLabels: false
 SortIncludes: false
 ReflowComments: true
-AlignConsecutiveAssignments: false
+AlignConsecutiveAssignments: true
 AlignTrailingComments: true
 AlignAfterOpenBracket: DontAlign
 ConstructorInitializerAllOnOneLineOrOnePerLine: false
@@ -30,3 +29,5 @@ BinPackParameters: true
 AlwaysBreakAfterReturnType: None
 KeepEmptyLinesAtTheStartOfBlocks: true
 IndentWrappedFunctionNames: false
+
+#SpaceAfterTemplateKeyword: false

.gdbinit

@@ -1,2 +0,0 @@
-handle SIGSEGV nostop noprint
-handle SIGPIPE nostop noprint

.github/FUNDING.yml

@@ -1,2 +0,0 @@
-patreon: Nekotekina
-custom: https://rpcs3.net/alipay

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,24 @@
+<!---
+
+THIS IS NOT A SUPPORT FORUM, FOR SUPPORT GO TO:
+https://forums.rpcs3.net
+or our discord:
+https://discord.me/RPCS3
+
+PLEASE READ THE GUIDELINES BEFORE OPENING AN ISSUE:
+https://github.com/RPCS3/rpcs3/blob/master/CONTRIBUTING.md
+
+====================================================
+
+When submitting an issue, please check the following:
+
+- You have read the above.
+- You have provided the version (commit hash) of RPCS3 you are using.
+- You have provided sufficient detail for the issue to be reproduced.
+- You have provided system specs.
+- Please also provide:
+  - For crashes, a backtrace.
+  - For graphical issues, comparison screenshots with real hardware.
+
+Remember that the GitHub Issue Tracker is not the place to ask for support or to submit Game Compatibility reports. You must use our forums for that.
+--->

.github/ISSUE_TEMPLATE/1-regression-report.yml

@@ -1,93 +0,0 @@
-name: Regression report
-description: If something used to work before, but now it doesn't
-title: "[Regression] Enter a title here"
-labels: []
-body:
-  - type: markdown
-    attributes:
-      value: |
-        # Summary
-        Please do not ask for help or report compatibility regressions here, use [RPCS3 Discord server](https://discord.me/RPCS3) or [forums](https://forums.rpcs3.net/) instead.
-  - type: textarea
-    id: quick-summary
-    attributes:
-      label: Quick summary
-      description: Please briefly describe what has stopped working correctly.
-    validations:
-      required: true
-  - type: textarea
-    id: details
-    attributes:
-      label: Details
-      description: Please describe the regression as accurately as possible. Include screenshots if neccessary.
-    validations:
-      required: false
-  - type: markdown
-    attributes:
-      value: |
-        # Identify the regressed build
-        Please provide the _exact_ build (or commit) information that introduced the regression you're reporting.
-        * Please see [How to find the build that caused a regression](https://wiki.rpcs3.net/index.php?title=Help:Using_different_versions_of_RPCS3#How_to_find_the_build_that_caused_a_regression.3F) in our wiki.
-        * You can find [History of RPCS3 builds](https://rpcs3.net/compatibility?b) here.
-
-        Make sure you're running with settings as close to default as possible
-        * **Do NOT enable any emulator game patches when reporting issues**
-        * Only change settings that are required for the game to work
-  - type: input
-    id: regressed-build
-    attributes:
-      label: Build with regression
-      description: Provide _exact_ build (or commit) information that introduced the regression you're reporting.
-      placeholder: v0.0.23-13948-31df99f7
-    validations:
-      required: true
-  - type: markdown
-    attributes:
-      value: |
-        # Log files
-        Obtaining the log file:
-        * Run the game until you find the regression.
-        * Completely close RPCS3 and locate the log file.
-
-        RPCS3's Log file will be ```RPCS3.log.gz``` (sometimes shows as RPCS3.log with zip icon) or ```RPCS3.log``` (sometimes shows as RPCS3 wtih notepad icon).
-        * On Windows it will be in the RPCS3 directory near the executable
-        * On Linux it will be in ```~/.cache/rpcs3/```
-        * On MacOS it will be in ```~/Library/Caches/rpcs3```. If you're unable to locate it copy paste the path in Spotlight and hit enter.
-  - type: textarea
-    id: logs
-    attributes:
-      label: Attach two log files
-      description: |
-        Attach one file for the build with regression and another for a build that works.
-        Drag & drop the files into this input field, or upload them to another service (f.ex. Dropbox, Mega) and provide a link.
-    validations:
-      required: true
-  - type: markdown
-    attributes:
-      value: |
-        # Other details
-        If you describe a graphical regression, please provide an RSX capture and/or a RenderDoc capture that demonstrate it.
-        * To create an RSX capture, use _Create_ _RSX_ _Capture_ under _Utilities_.
-        * Captures will be stored in RPCS3 folder → captures.
-        * To create a RenderDoc capture, please refer to [RenderDoc's documentation](https://renderdoc.org/docs/how/how_capture_frame.html).
-  - type: textarea
-    id: captures
-    attributes:
-      label: Attach capture files for visual issues
-      description: Compress your capture with 7z, Rar etc. and attach it here, or upload it to the cloud (Dropbox, Mega etc) and add a link to it.
-    validations:
-      required: false
-  - type: textarea
-    id: system-info
-    attributes:
-      label: System configuration
-      description: Provide information about your system, such as operating system, CPU and GPU model, GPU driver version and other information that describes your system configuration.
-    validations:
-      required: false
-  - type: textarea
-    id: other-details
-    attributes:
-      label: Other details
-      description: Include anything else you deem to be important.
-    validations:
-      required: false

.github/ISSUE_TEMPLATE/2-bug-report.yml

@@ -1,78 +0,0 @@
-name: Bug report
-description: If something doesn't work correctly in RPCS3
-title: "Enter a title here"
-labels: []
-body:
-  - type: markdown
-    attributes:
-      value: |
-        # Summary
-        Please do not ask for help or report compatibility regressions here, use [RPCS3 Discord server](https://discord.me/RPCS3) or [forums](https://forums.rpcs3.net/) instead.
-  - type: textarea
-    id: quick-summary
-    attributes:
-      label: Quick summary
-      description: Please briefly describe what is not working correctly.
-    validations:
-      required: true
-  - type: textarea
-    id: details
-    attributes:
-      label: Details
-      description: |
-        Please describe the problem as accurately as possible.
-        Provide a comparison with a real PS3, if possible.
-    validations:
-      required: false
-  - type: markdown
-    attributes:
-      value: |
-        # Log files
-
-        Provide a log file that includes the bug you're reporting.
-
-        Obtaining the log file:
-        * Run the game until you find the regression.
-        * Completely close RPCS3 and locate the log file.
-
-        RPCS3's Log file will be ```RPCS3.log.gz``` (sometimes shows as RPCS3.log with zip icon) or ```RPCS3.log``` (sometimes shows as RPCS3 wtih notepad icon).
-        * On Windows it will be in the RPCS3 directory near the executable
-        * On Linux it will be in ```~/.cache/rpcs3/```
-        * On MacOS it will be in ```~/Library/Caches/rpcs3```. If you're unable to locate it copy paste the path in Spotlight and hit enter.
-  - type: textarea
-    id: logs
-    attributes:
-      label: Attach a log file
-      description: |
-        Drag & drop the files into this input field, or upload them to another service (f.ex. Dropbox, Mega) and provide a link.
-    validations:
-      required: true
-  - type: markdown
-    attributes:
-      value: |
-        # Other details
-        If you describe a graphical issue, please provide an RSX capture and/or a RenderDoc capture that demonstrate it.
-        * To create an RSX capture, use _Create_ _RSX_ _Capture_ under _Utilities_.
-        * Captures will be stored in RPCS3 folder → captures.
-        * To create a RenderDoc capture, please refer to [RenderDoc's documentation](https://renderdoc.org/docs/how/how_capture_frame.html).
-  - type: textarea
-    id: captures
-    attributes:
-      label: Attach capture files for visual issues
-      description: Compress your capture with 7z, Rar etc. and attach it here, or upload it to the cloud (Dropbox, Mega etc) and add a link to it.
-    validations:
-      required: false
-  - type: textarea
-    id: system-info
-    attributes:
-      label: System configuration
-      description: Provide information about your system, such as operating system, CPU and GPU model, GPU driver version and other information that describes your system configuration.
-    validations:
-      required: false
-  - type: textarea
-    id: other-details
-    attributes:
-      label: Other details
-      description: Include anything else you deem to be important.
-    validations:
-      required: false

.github/ISSUE_TEMPLATE/3-feature-request.yml

@@ -1,36 +0,0 @@
-name: Feature request
-description: If RPCS3 lacks a feature you would like to see
-title: "[Feature request] Enter a title here"
-labels: []
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Please do not ask for help or report compatibility regressions here, use [RPCS3 Discord server](https://discord.me/RPCS3) or [forums](https://forums.rpcs3.net/) instead.
-  - type: textarea
-    id: quick-summary
-    attributes:
-      label: Quick summary
-      description: Please briefly describe what feature you would like RPCS3 to have.
-    validations:
-      required: true
-  - type: textarea
-    id: details
-    attributes:
-      label: Details
-      description: Please describe the feature as accurately as possible.
-    validations:
-      required: false
-  - type: markdown
-    attributes:
-      value: |
-        Please include the following information:
-        * What part of RPCS3 would be affected by your feature? (Gameplay, Debugging, UI, Patches, Installation, CI etc.)
-        * Why your feature is important to RPCS3.
-        * If the feature is implemented in other projects, attach screenshots.
-        * If this feature is something that a game is trying to use, upload a log file for it.
-
-        RPCS3's Log file will be ```RPCS3.log.gz``` (sometimes shows as RPCS3.log with zip icon) or ```RPCS3.log``` (sometimes shows as RPCS3 wtih notepad icon).
-        * On Windows it will be in the RPCS3 directory near the executable
-        * On Linux it will be in ```~/.cache/rpcs3/```
-        * On MacOS it will be in ```~/Library/Caches/rpcs3```. If you're unable to locate it copy paste the path in Spotlight and hit enter.

.github/ISSUE_TEMPLATE/4-advanced.md

@@ -1,14 +0,0 @@
----
-name: Advanced
-about: For developers and experienced users only
-title: ''
-labels: ''
-assignees: ''
-
----
-
-## Please do not ask for help or report compatibility regressions here, use [RPCS3 Discord server](https://discord.me/RPCS3) or [forums](https://forums.rpcs3.net/) instead.
-
-You're using the advanced template. You're expected to know what to write in order to fill in all the required information for proper report.
-
-If you're unsure on what to do, please return back to the issue type selection and choose different category.

.github/ISSUE_TEMPLATE/config.yml

@@ -1,11 +0,0 @@
-blank_issues_enabled: false
-contact_links:
-  - name: Quickstart guide
-    url: https://rpcs3.net/quickstart
-    about: Everything you need to know to install and configure emulator, and add games
-  - name: Ask for help
-    url: https://discord.me/RPCS3
-    about: If you have some questions or need help, please use our Discord server instead of GitHub
-  - name: Report game compatibility
-    url: https://forums.rpcs3.net/thread-196671.html
-    about: Please use RPCS3 forums to submit or update game compatibility status

.github/PR-BUILD.md

@@ -1,18 +0,0 @@
-## How to test a PR build
-
-Please take into account, that RPCS3 build usually takes some time (about 15 mins), so you can't access a build if a PR was just submitted.
-
-- Open a PR you want to test
-- Scroll to the very bottom and locate the **Checks** section
-- Click on **Show all checks**
-	You are supposed to see something like this
-	![image](https://user-images.githubusercontent.com/10283761/116630952-2cd99e00-a94c-11eb-933e-986d6020ca92.png)
-- Click on __Details__ on either **Cirrus Linux GCC** or **Cirrus Windows**
-- Click **View more details on Cirrus CI** at the very bottom
-	![image](https://user-images.githubusercontent.com/10283761/116631111-5e526980-a94c-11eb-95f7-751e6f15e1ea.png)
-- Click on the download button for **Artifact** on the **Artifacts** block
-	![image](https://user-images.githubusercontent.com/10283761/116631322-bee1a680-a94c-11eb-89a3-be365783582e.png)
-
-- Congratulations! You are now downloading an RPCS3 build for that specific PR.
-
-__Please note that PR builds are not supposed to be stable because they contain new changesets.__

.github/PULL_REQUEST_TEMPLATE/1-default.md

@@ -1,3 +0,0 @@
-<!-- Please include a summary of the change and which issue is fixed. -->
-
-[How to test this PR](.github/PR-BUILD.md)

.gitignore

@@ -9,7 +9,7 @@
 # Compiled Static libraries
 *.lai
 *.la
-*.a
+# *.a # Commented out since OpenAL Soft's binaries use this extension.
 *.opensdf
 *.sdf
 *.suo
@@ -31,107 +31,69 @@
 *.wav
 
 /build
+/bin
 /lib
 /tmp
 /ipch
 /rpcs3/Debug
 /rpcs3/Release
-
-!/bin
-/bin/*
-
-# Audio DLLs
-!/bin/soft_oal.dll
-!/bin/xaudio2_9redist.dll
-
-# Test Programs
-!/bin/test/
+/llvm_build
+/Vulkan/Vulkan-build
+/Vulkan/glslang-build
 
 # Themes
 !/bin/GuiConfigs/
 /bin/GuiConfigs/*.ini
-/bin/GuiConfigs/*.ini.*
-/bin/GuiConfigs/*.dat
-/bin/GuiConfigs/*.dat.*
 
-# Some data from git
-!/bin/git/
+/bin/rpcs3.ini
+/bin/rpcs3.ipdb
+/bin/rpcs3.iobj
+/bin/FragmentProgram.txt
+/bin/VertexProgram.txt
+/bin/*.hlsl
+/bin/BreakPoints.dat
+/bin/textures
+/bin/*.lib
+/bin/*.exp
+rpcs3/git-version.h
 
 # Visual Studio Files
 .vs/*
-.vscode/*
-*.ipch
 *.vspx
 *.psess
 *.VC.*
 *.vcxproj.user
-enc_temp_folder/*
-CMakeSettings.json
-*PVS-Studio*
-PVS/*
+
+# Copyrighted files
+/bin/data/
+/bin/dev_flash/data/font
+/bin/dev_flash/sys
+/bin/dev_flash/vsh
+
+# Ignore installed games except test homebrews
+!/bin/dev_hdd0/game/
+/bin/dev_hdd0/game/*
+!/bin/dev_hdd0/game/TEST12345/
+/bin/dev_hdd0/disc/*
 
 # Ignore other system generated files
+bin/dev_hdd0/*.txt
 x64/*
 rpcs3/x64/*
-rpcs3/git-version.h
+rpcs3-tests/x64/*
 
 # cmake
 Makefile
 *CMakeFiles*
 CMakeCache.txt
 *cmake_install.cmake*
-CPackConfig.cmake
-CPackSourceConfig.cmake
-compile_commands.json
 
 # cotire
 rpcs3/cotire/*
 rpcs3/rpcs3_*_cotire.cmake
-rpcs3/Emu/rpcs3_emu_CXX_Release_cotire.cmake
-rpcs3/Emu/rpcs3_emu_CXX_cotire.cmake
-
-# kdevelop
-*.kdev4
-.kdev4/*
 
 # Qt
 moc_*.cpp
-qrc_*.cpp
+qrc_resources.cpp
 rpcs3_automoc.cpp
 ui_*.h
-rpcs3/rpcs3_autogen/*
-
-# QtCreator
-CMakeLists.txt.user
-*.autosave
-
-# CLion
-/.idea/*
-/cmake-build-*/
-
-# macOS
-.DS_Store
-
-# 7zlib
-/3rdparty/7z/**/*.lib
-
-# yaml-cpp
-yaml-cpp.pc
-
-# libusb
-/3rdparty/libusb_cmake/config.h
-/3rdparty/libusb_cmake/libusb-1.0.pc
-
-# miniupnp
-/3rdparty/miniupnp/x64/*
-
-# llvm
-/3rdparty/llvm/llvm_build
-
-# legacy llvm
-/llvm_build
-
-# ssl certificate
-cacert.pem
-
-_ReSharper.*/

.gitmodules

@@ -1,89 +1,44 @@
 [submodule "rpcs3-ffmpeg"]
 	path = 3rdparty/ffmpeg
-	url = ../../RPCS3/ffmpeg-core.git
-	ignore = dirty
+	url = https://github.com/hrydgard/ppsspp-ffmpeg
 [submodule "asmjit"]
-	path = 3rdparty/asmjit/asmjit
-	url = ../../RPCS3/asmjit.git
-	branch = aarch64
+	path = asmjit
+	url = https://github.com/kobalicek/asmjit
 	ignore = dirty
-[submodule "3rdparty/llvm/llvm"]
-	path = 3rdparty/llvm/llvm
-	url = ../../llvm/llvm-project.git
-	ignore = dirty
-[submodule "3rdparty/glslang"]
-	path = 3rdparty/glslang/glslang
-	url = ../../KhronosGroup/glslang.git
-	ignore = dirty
-[submodule "3rdparty/SPIRV-Tools"]
-	path = 3rdparty/SPIRV/SPIRV-Tools
-	url = ../../KhronosGroup/SPIRV-Tools.git
-	ignore = dirty
-[submodule "3rdparty/SPIRV-Headers"]
-	path = 3rdparty/SPIRV/SPIRV-Headers
-	url = ../../KhronosGroup/SPIRV-Headers.git
+[submodule "llvm"]
+	path = llvm
+	url = https://github.com/RPCS3/llvm
+	branch = release_60
+[submodule "GSL"]
+	path = 3rdparty/GSL
+	url = https://github.com/Microsoft/GSL.git
+[submodule "libpng"]
+	path = 3rdparty/libpng
+	url = https://github.com/RPCS3/libpng
 	ignore = dirty
+[submodule "Vulkan/glslang"]
+	path = Vulkan/glslang
+	url = https://github.com/KhronosGroup/glslang.git
+[submodule "Vulkan/Vulkan-LoaderAndValidationLayers"]
+	path = Vulkan/Vulkan-LoaderAndValidationLayers
+	url = https://github.com/KhronosGroup/Vulkan-LoaderAndValidationLayers
+[submodule "Utilities/yaml-cpp"]
+	path = Utilities/yaml-cpp
+	url = https://github.com/RPCS3/yaml-cpp
+[submodule "3rdparty/cereal"]
+	path = 3rdparty/cereal
+	url = https://github.com/USCiLab/cereal.git
 [submodule "3rdparty/zlib"]
-	path = 3rdparty/zlib/zlib
-	url = ../../madler/zlib
-	ignore = dirty
+	path = 3rdparty/zlib
+	url = https://github.com/madler/zlib
 [submodule "3rdparty/hidapi"]
-	path = 3rdparty/hidapi/hidapi
-	url = ../../RPCS3/hidapi.git
+	path = 3rdparty/hidapi
+	url = https://github.com/RPCS3/hidapi
 	branch = master
 	ignore = dirty
+[submodule "3rdparty/Optional"]
+	path = 3rdparty/Optional
+	url = https://github.com/akrzemi1/Optional.git
 [submodule "3rdparty/pugixml"]
 	path = 3rdparty/pugixml
-	url = ../../zeux/pugixml.git
-	ignore = dirty
-[submodule "3rdparty/xxHash"]
-	path = 3rdparty/xxHash
-	url = ../../Cyan4973/xxHash.git
-	ignore = dirty
-[submodule "3rdparty/yaml-cpp"]
-	path = 3rdparty/yaml-cpp/yaml-cpp
-	url = ../../RPCS3/yaml-cpp.git
-	ignore = dirty
-[submodule "3rdparty/libpng"]
-	path = 3rdparty/libpng/libpng
-	url = ../../glennrp/libpng.git
-	ignore = dirty
-[submodule "3rdparty/libusb"]
-	path = 3rdparty/libusb/libusb
-	url = ../../libusb/libusb.git
-	ignore = dirty
-[submodule "3rdparty/FAudio"]
-	path = 3rdparty/FAudio
-	url = ../../FNA-XNA/FAudio.git
-	ignore = dirty
-[submodule "3rdparty/curl"]
-	path = 3rdparty/curl/curl
-	url = ../../curl/curl.git
-	ignore = dirty
-[submodule "3rdparty/wolfssl"]
-	path = 3rdparty/wolfssl/wolfssl
-	url = ../../wolfSSL/wolfssl.git
-	ignore = dirty
-[submodule "3rdparty/flatbuffers"]
-	path = 3rdparty/flatbuffers
-	url = ../../google/flatbuffers.git
-	ignore = dirty
-[submodule "3rdparty/cubeb/cubeb"]
-	path = 3rdparty/cubeb/cubeb
-	url = ../../mozilla/cubeb.git
-	ignore = dirty
-[submodule "3rdparty/SoundTouch/soundtouch"]
-	path = 3rdparty/SoundTouch/soundtouch
-	url = ../../RPCS3/soundtouch.git
-	ignore = dirty
-[submodule "3rdparty/libsdl-org/SDL"]
-	path = 3rdparty/libsdl-org/SDL
-	url = ../../libsdl-org/SDL.git
-	ignore = dirty
-[submodule "3rdparty/miniupnp/miniupnp"]
-	path = 3rdparty/miniupnp/miniupnp
-	url = ../../miniupnp/miniupnp.git
-	ignore = dirty
-[submodule "3rdparty/rtmidi/rtmidi"]
-	path = 3rdparty/rtmidi/rtmidi
-	url = ../../thestk/rtmidi
+	url = https://github.com/zeux/pugixml

.mention-bot

@@ -0,0 +1,3 @@
+{
+  "userBlacklist": ["AlexAltea", "tambry", "DHrpcs3"]
+}

.travis.yml

@@ -0,0 +1,124 @@
+language: cpp
+sudo: required
+
+os:
+  - linux
+  #- osx
+
+# osx_image: xcode6.4
+
+compiler:
+  - clang
+  - gcc
+
+cache:
+  ccache: true
+  directories:
+    - $HOME/hombebrew_cache
+
+matrix:
+  exclude:
+    - os: osx
+      compiler: gcc
+
+git:
+  depth: false # Unshallow clone to obtain proper GIT_VERSION
+  submodules: false
+
+before_install:
+  - if [ "$TRAVIS_OS_NAME" = "linux" ] && [ "$CXX" = "g++" ]; then
+      export CXX="g++-5" CC="gcc-5" CXXFLAGS="-Wno-format-security";
+    fi;
+  - if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+      wget http://download.qt.io/official_releases/online_installers/qt-unified-linux-x64-online.run ;
+      chmod a+x ./qt-unified-linux-x64-online.run ;
+      export QT_QPA_PLATFORM=minimal ;
+      travis_wait 60 ./qt-unified-linux-x64-online.run --script qt-installer-noninteractive.qs --no-force-installations --verbose ;
+    fi;
+
+  # Install updated libglew-dev since the version provided by trusty is outdated
+  - if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+      wget https://mirrors.kernel.org/ubuntu/pool/universe/g/glew/libglew-dev_2.0.0-5_amd64.deb;
+      wget https://mirrors.kernel.org/ubuntu/pool/universe/g/glew/libglew2.0_2.0.0-5_amd64.deb;
+      wget https://mirrors.kernel.org/ubuntu/pool/universe/v/vulkan/libvulkan1_1.0.61.1+dfsg1-1ubuntu1~16.04.1_amd64.deb;
+      wget https://mirrors.kernel.org/ubuntu/pool/universe/v/vulkan/libvulkan-dev_1.0.61.1+dfsg1-1ubuntu1~16.04.1_amd64.deb;
+      sudo dpkg -i libglew2.0_2.0.0-5_amd64.deb libglew-dev_2.0.0-5_amd64.deb libvulkan1_1.0.61.1+dfsg1-1ubuntu1~16.04.1_amd64.deb libvulkan-dev_1.0.61.1+dfsg1-1ubuntu1~16.04.1_amd64.deb;
+    else
+      brew update;
+      brew install ccache glew llvm40;
+    fi;
+
+before_script:
+  - git submodule update --init asmjit 3rdparty/ffmpeg 3rdparty/pugixml 3rdparty/GSL 3rdparty/libpng Utilities/yaml-cpp 3rdparty/cereal 3rdparty/hidapi 3rdparty/Optional Vulkan/glslang Vulkan/Vulkan-LoaderAndValidationLayers
+  - mkdir build
+  - cd build
+  - export CMAKE_PREFIX_PATH=~/Qt/5.10.0/gcc_64/lib/cmake
+  - export CXXFLAGS="$CXXFLAGS -DTRAVIS=true";
+  - if [ "$TRAVIS_PULL_REQUEST" = false ]; then
+      export CXXFLAGS="$CXXFLAGS -DBRANCH=$TRAVIS_REPO_SLUG/$TRAVIS_BRANCH";
+    else
+      export CXXFLAGS="$CXXFLAGS -DBRANCH=$TRAVIS_REPO_SLUG/$TRAVIS_BRANCH/#$TRAVIS_PULL_REQUEST";
+    fi;
+  - cmake .. -DCMAKE_INSTALL_PREFIX=/usr -G Ninja;
+  - ninja
+  - # AppImage generation
+  - if [ -n "$UPLOAD_URL" ] && [ "$TRAVIS_BRANCH" = "master" ] && [ "$CC" = "clang" ] && [ "$TRAVIS_PULL_REQUEST" = false ]; then
+      export LD_LIBRARY_PATH=~/Qt/5.10.0/gcc_64/lib;
+      DESTDIR=appdir ninja install ; find appdir/ ;
+      find ../bin ;
+      wget -c "https://github.com/probonopd/linuxdeployqt/releases/download/continuous/linuxdeployqt-continuous-x86_64.AppImage" ;
+      chmod a+x linuxdeployqt*.AppImage ;
+      export PATH=~/Qt/5.10.0/gcc_64/bin/:${PATH} ;
+      ./linuxdeployqt*.AppImage --appimage-extract ;
+      ./linuxdeployqt*.AppImage ./appdir/usr/share/applications/*.desktop -bundle-non-qt-libs ;
+      mkdir ./appdir/usr/plugins/xcbglintegrations/ ;
+      mkdir ./appdir/usr/plugins/imageformats/ ;
+      cp ~/Qt/5.10.0/gcc_64/lib/libQt5Svg.so.5 ./appdir/usr/lib/ ;
+      cp ~/Qt/5.10.0/gcc_64/plugins/xcbglintegrations/* ./appdir/usr/plugins/xcbglintegrations/ ;
+      cp ~/Qt/5.10.0/gcc_64/plugins/imageformats/* ./appdir/usr/plugins/imageformats/ ;
+      cp ~/Qt/5.10.0/gcc_64/plugins/platforms/* ./appdir/usr/plugins/platforms/ ;
+      rm ./appdir/usr/lib/libfreetype.so.6 ;
+      export PATH=${TRAVIS_BUILD_DIR}/build/squashfs-root/usr/bin/:${PATH} ;
+      ./squashfs-root/usr/bin/appimagetool ${TRAVIS_BUILD_DIR}/build/appdir ;
+      find ./appdir -executable -type f -exec ldd {} \; | grep " => /usr" | cut -d " " -f 2-3 | sort | uniq ;
+      curl ${UPLOAD_URL}${TRAVIS_COMMIT:0:7}-${TRAVIS_BUILD_NUMBER}_linux64 --upload-file ./RPCS3*.AppImage;
+   fi;
+
+script:
+  # Add a command to show all the variables. May be useful for debugging Travis.
+  #- echo "--Shell Export Lists START--" ; export -p; echo "--Shell Export Lists STOP--";
+  # And to ensure the versions of toolchain
+  - echo "--CXX version?"; "$CXX" --version; echo "--CXX version confirmed";
+
+addons:
+  apt:
+    sources:
+      - ubuntu-toolchain-r-test
+      - llvm-toolchain-trusty-4.0
+      - sourceline: 'ppa:jonathonf/binutils' # We need to update binutils to a newer version to link against the ffmpeg libs on.
+    packages:
+      - binutils
+      - cmake
+      - ninja-build
+      - libasound2-dev
+      - libopenal-dev
+      - freeglut3-dev
+      #- libglew-dev
+      #- libvulkan1
+      #- libvulkan-dev
+      - libc6-dev
+      - llvm-4.0
+      - llvm-4.0-dev
+      # Clang 5.0 is now bundled in travis, so we no longer need the ppa version.
+      #- clang-4.0
+      - libedit-dev
+      - g++-5
+      - gcc-5
+      - libstdc++-5-dev
+      - lib32stdc++6
+      - zlib1g-dev
+      # We need to install qt 5.10.0 manually because the version trusty provides is too old.
+      #- qtbase5-dev
+      - libudev-dev
+      - libevdev-dev
+      - libpulse-dev

3rdparty/7z/7zlib.vcxproj

@@ -1,244 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="src\7z.h" />
-    <ClInclude Include="src\7zAlloc.h" />
-    <ClInclude Include="src\7zBuf.h" />
-    <ClInclude Include="src\7zCrc.h" />
-    <ClInclude Include="src\7zFile.h" />
-    <ClInclude Include="src\7zTypes.h" />
-    <ClInclude Include="src\7zVersion.h" />
-    <ClInclude Include="src\Aes.h" />
-    <ClInclude Include="src\Alloc.h" />
-    <ClInclude Include="src\Bcj2.h" />
-    <ClInclude Include="src\Bra.h" />
-    <ClInclude Include="src\Compiler.h" />
-    <ClInclude Include="src\CpuArch.h" />
-    <ClInclude Include="src\Delta.h" />
-    <ClInclude Include="src\DllSecur.h" />
-    <ClInclude Include="src\LzFind.h" />
-    <ClInclude Include="src\LzFindMt.h" />
-    <ClInclude Include="src\LzHash.h" />
-    <ClInclude Include="src\Lzma2Dec.h" />
-    <ClInclude Include="src\Lzma2DecMt.h" />
-    <ClInclude Include="src\Lzma2Enc.h" />
-    <ClInclude Include="src\Lzma86.h" />
-    <ClInclude Include="src\LzmaDec.h" />
-    <ClInclude Include="src\LzmaEnc.h" />
-    <ClInclude Include="src\LzmaLib.h" />
-    <ClInclude Include="src\MtCoder.h" />
-    <ClInclude Include="src\MtDec.h" />
-    <ClInclude Include="src\Ppmd.h" />
-    <ClInclude Include="src\Ppmd7.h" />
-    <ClInclude Include="src\Precomp.h" />
-    <ClInclude Include="src\RotateDefs.h" />
-    <ClInclude Include="src\Sha256.h" />
-    <ClInclude Include="src\Sort.h" />
-    <ClInclude Include="src\Threads.h" />
-    <ClInclude Include="src\Xz.h" />
-    <ClInclude Include="src\XzCrc64.h" />
-    <ClInclude Include="src\XzEnc.h" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="src\7zAlloc.c" />
-    <ClCompile Include="src\7zArcIn.c" />
-    <ClCompile Include="src\7zBuf.c" />
-    <ClCompile Include="src\7zBuf2.c" />
-    <ClCompile Include="src\7zCrc.c" />
-    <ClCompile Include="src\7zCrcOpt.c" />
-    <ClCompile Include="src\7zDec.c" />
-    <ClCompile Include="src\7zFile.c" />
-    <ClCompile Include="src\7zStream.c" />
-    <ClCompile Include="src\Aes.c" />
-    <ClCompile Include="src\AesOpt.c" />
-    <ClCompile Include="src\Alloc.c" />
-    <ClCompile Include="src\Bcj2.c" />
-    <ClCompile Include="src\Bcj2Enc.c" />
-    <ClCompile Include="src\Bra.c" />
-    <ClCompile Include="src\Bra86.c" />
-    <ClCompile Include="src\BraIA64.c" />
-    <ClCompile Include="src\CpuArch.c" />
-    <ClCompile Include="src\Delta.c" />
-    <ClCompile Include="src\DllSecur.c" />
-    <ClCompile Include="src\LzFind.c" />
-    <ClCompile Include="src\LzFindMt.c" />
-    <ClCompile Include="src\Lzma2Dec.c" />
-    <ClCompile Include="src\Lzma2DecMt.c" />
-    <ClCompile Include="src\Lzma2Enc.c" />
-    <ClCompile Include="src\Lzma86Dec.c" />
-    <ClCompile Include="src\Lzma86Enc.c" />
-    <ClCompile Include="src\LzmaDec.c" />
-    <ClCompile Include="src\LzmaEnc.c" />
-    <ClCompile Include="src\LzmaLib.c" />
-    <ClCompile Include="src\MtCoder.c" />
-    <ClCompile Include="src\MtDec.c" />
-    <ClCompile Include="src\Ppmd7.c" />
-    <ClCompile Include="src\Ppmd7Dec.c" />
-    <ClCompile Include="src\Ppmd7Enc.c" />
-    <ClCompile Include="src\Sha256.c" />
-    <ClCompile Include="src\Sort.c" />
-    <ClCompile Include="src\Threads.c" />
-    <ClCompile Include="src\Xz.c" />
-    <ClCompile Include="src\XzCrc64.c" />
-    <ClCompile Include="src\XzCrc64Opt.c" />
-    <ClCompile Include="src\XzDec.c" />
-    <ClCompile Include="src\XzEnc.c" />
-    <ClCompile Include="src\XzIn.c" />
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <VCProjectVersion>16.0</VCProjectVersion>
-    <ProjectGuid>{5B146DEA-9ACE-4D32-A7FD-3F42464DD69C}</ProjectGuid>
-    <Keyword>Win32Proj</Keyword>
-    <RootNamespace>My7zlib</RootNamespace>
-  </PropertyGroup>
-  <Import Project="$(SolutionDir)\buildfiles\msvc\common_default.props" />
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup>
-    <PreferredToolArchitecture>x64</PreferredToolArchitecture>
-  </PropertyGroup>
-  <Import Project="$(SolutionDir)\buildfiles\msvc\common_default_macros.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="Shared">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup>
-    <OutDir>$(SolutionDir)lib/$(Configuration)-$(Platform)/</OutDir>
-    <IntDir>$(SolutionDir)tmp\$(ProjectName)-$(Configuration)-$(Platform)/</IntDir>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <LinkIncremental>false</LinkIncremental>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <LinkIncremental>true</LinkIncremental>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <LinkIncremental>true</LinkIncremental>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <LinkIncremental>false</LinkIncremental>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <ClCompile>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <ConformanceMode>true</ConformanceMode>
-      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <ConformanceMode>true</ConformanceMode>
-      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <ConformanceMode>true</ConformanceMode>
-      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <ConformanceMode>true</ConformanceMode>
-      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

3rdparty/7z/7zlib.vcxproj.filters

@@ -1,264 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hh;hpp;hxx;hm;inl;inc;ipp;xsd</Extensions>
-    </Filter>
-    <Filter Include="Resource Files">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include"src\7z.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\7zAlloc.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\7zBuf.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\7zCrc.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\7zFile.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\7zTypes.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\7zVersion.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\Aes.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\Alloc.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\Bcj2.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\Bra.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\Compiler.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\CpuArch.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\Delta.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\DllSecur.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\LzFind.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\LzFindMt.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\LzHash.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\Lzma2Dec.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\Lzma2DecMt.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\Lzma2Enc.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\Lzma86.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\LzmaDec.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\LzmaEnc.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\LzmaLib.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\MtCoder.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\MtDec.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\Ppmd.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\Ppmd7.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\Precomp.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\RotateDefs.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\Sha256.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\Sort.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\Threads.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\Xz.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\XzCrc64.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include"src\XzEnc.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include"src\7zAlloc.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\7zArcIn.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\7zBuf.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\7zBuf2.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\7zCrc.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\7zCrcOpt.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\7zDec.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\7zFile.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\7zStream.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\Aes.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\AesOpt.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\Alloc.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\Bcj2.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\Bcj2Enc.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\Bra.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\Bra86.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\BraIA64.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\CpuArch.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\Delta.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\DllSecur.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\LzFind.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\LzFindMt.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\Lzma2Dec.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\Lzma2DecMt.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\Lzma2Enc.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\Lzma86Dec.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\Lzma86Enc.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\LzmaDec.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\LzmaEnc.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\LzmaLib.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\MtCoder.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\MtDec.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\Ppmd7.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\Ppmd7Dec.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\Ppmd7Enc.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\Sha256.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\Sort.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\Threads.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\Xz.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\XzCrc64.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\XzCrc64Opt.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\XzDec.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\XzEnc.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include"src\XzIn.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-  </ItemGroup>
-</Project>

3rdparty/7z/CMakeLists.txt

@@ -1,58 +0,0 @@
-# 7z sdk
-if(WIN32)
-	add_library(3rdparty_7z STATIC EXCLUDE_FROM_ALL
-		src/Sha256.c
-		src/Ppmd7Dec.c
-		src/XzDec.c
-		src/XzEnc.c
-		src/Lzma2Dec.c
-		src/XzCrc64.c
-		src/DllSecur.c
-		src/Lzma2DecMt.c
-		src/BraIA64.c
-		src/7zFile.c
-		src/7zStream.c
-		src/Lzma86Enc.c
-		src/Threads.c
-		src/7zAlloc.c
-		src/LzmaEnc.c
-		src/MtCoder.c
-		src/Lzma86Dec.c
-		src/Sort.c
-		src/LzFindMt.c
-		src/7zDec.c
-		src/Bcj2.c
-		src/Ppmd7.c
-		src/Bra86.c
-		src/Bcj2Enc.c
-		src/7zBuf.c
-		src/Aes.c
-		src/AesOpt.c
-		src/XzCrc64Opt.c
-		src/7zArcIn.c
-		src/Lzma2Enc.c
-		src/Bra.c
-		src/7zCrcOpt.c
-		src/7zBuf2.c
-		src/LzFind.c
-		src/Ppmd7Enc.c
-		src/CpuArch.c
-		src/Delta.c
-		src/XzIn.c
-		src/Alloc.c
-		src/Xz.c
-		src/LzmaDec.c
-		src/LzmaLib.c
-		src/7zCrc.c
-		src/MtDec.c)
-	target_include_directories(3rdparty_7z INTERFACE
-		$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
-		$<INSTALL_INTERFACE:/src>)
-
-	target_include_directories(3rdparty_7z INTERFACE 7z)
-
-	set_property(TARGET 3rdparty_7z PROPERTY FOLDER "3rdparty/")
-
-else()
-	add_library(3rdparty_7z INTERFACE)
-endif()

3rdparty/7z/src/7z.h

@@ -1,204 +0,0 @@
-/* 7z.h -- 7z interface
-2018-07-02 : Igor Pavlov : Public domain */
-
-#ifndef __7Z_H
-#define __7Z_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-#define k7zStartHeaderSize 0x20
-#define k7zSignatureSize 6
-
-extern const Byte k7zSignature[k7zSignatureSize];
-
-typedef struct
-{
-  const Byte *Data;
-  size_t Size;
-} CSzData;
-
-/* CSzCoderInfo & CSzFolder support only default methods */
-
-typedef struct
-{
-  size_t PropsOffset;
-  UInt32 MethodID;
-  Byte NumStreams;
-  Byte PropsSize;
-} CSzCoderInfo;
-
-typedef struct
-{
-  UInt32 InIndex;
-  UInt32 OutIndex;
-} CSzBond;
-
-#define SZ_NUM_CODERS_IN_FOLDER_MAX 4
-#define SZ_NUM_BONDS_IN_FOLDER_MAX 3
-#define SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX 4
-
-typedef struct
-{
-  UInt32 NumCoders;
-  UInt32 NumBonds;
-  UInt32 NumPackStreams;
-  UInt32 UnpackStream;
-  UInt32 PackStreams[SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX];
-  CSzBond Bonds[SZ_NUM_BONDS_IN_FOLDER_MAX];
-  CSzCoderInfo Coders[SZ_NUM_CODERS_IN_FOLDER_MAX];
-} CSzFolder;
-
-
-SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd);
-
-typedef struct
-{
-  UInt32 Low;
-  UInt32 High;
-} CNtfsFileTime;
-
-typedef struct
-{
-  Byte *Defs; /* MSB 0 bit numbering */
-  UInt32 *Vals;
-} CSzBitUi32s;
-
-typedef struct
-{
-  Byte *Defs; /* MSB 0 bit numbering */
-  // UInt64 *Vals;
-  CNtfsFileTime *Vals;
-} CSzBitUi64s;
-
-#define SzBitArray_Check(p, i) (((p)[(i) >> 3] & (0x80 >> ((i) & 7))) != 0)
-
-#define SzBitWithVals_Check(p, i) ((p)->Defs && ((p)->Defs[(i) >> 3] & (0x80 >> ((i) & 7))) != 0)
-
-typedef struct
-{
-  UInt32 NumPackStreams;
-  UInt32 NumFolders;
-
-  UInt64 *PackPositions;          // NumPackStreams + 1
-  CSzBitUi32s FolderCRCs;         // NumFolders
-
-  size_t *FoCodersOffsets;        // NumFolders + 1
-  UInt32 *FoStartPackStreamIndex; // NumFolders + 1
-  UInt32 *FoToCoderUnpackSizes;   // NumFolders + 1
-  Byte *FoToMainUnpackSizeIndex;  // NumFolders
-  UInt64 *CoderUnpackSizes;       // for all coders in all folders
-
-  Byte *CodersData;
-
-  UInt64 RangeLimit;
-} CSzAr;
-
-UInt64 SzAr_GetFolderUnpackSize(const CSzAr *p, UInt32 folderIndex);
-
-SRes SzAr_DecodeFolder(const CSzAr *p, UInt32 folderIndex,
-    ILookInStream *stream, UInt64 startPos,
-    Byte *outBuffer, size_t outSize,
-    ISzAllocPtr allocMain);
-
-typedef struct
-{
-  CSzAr db;
-
-  UInt64 startPosAfterHeader;
-  UInt64 dataPos;
-  
-  UInt32 NumFiles;
-
-  UInt64 *UnpackPositions;  // NumFiles + 1
-  // Byte *IsEmptyFiles;
-  Byte *IsDirs;
-  CSzBitUi32s CRCs;
-
-  CSzBitUi32s Attribs;
-  // CSzBitUi32s Parents;
-  CSzBitUi64s MTime;
-  CSzBitUi64s CTime;
-
-  UInt32 *FolderToFile;   // NumFolders + 1
-  UInt32 *FileToFolder;   // NumFiles
-
-  size_t *FileNameOffsets; /* in 2-byte steps */
-  Byte *FileNames;  /* UTF-16-LE */
-} CSzArEx;
-
-#define SzArEx_IsDir(p, i) (SzBitArray_Check((p)->IsDirs, i))
-
-#define SzArEx_GetFileSize(p, i) ((p)->UnpackPositions[(i) + 1] - (p)->UnpackPositions[i])
-
-void SzArEx_Init(CSzArEx *p);
-void SzArEx_Free(CSzArEx *p, ISzAllocPtr alloc);
-UInt64 SzArEx_GetFolderStreamPos(const CSzArEx *p, UInt32 folderIndex, UInt32 indexInFolder);
-int SzArEx_GetFolderFullPackSize(const CSzArEx *p, UInt32 folderIndex, UInt64 *resSize);
-
-/*
-if dest == NULL, the return value specifies the required size of the buffer,
-  in 16-bit characters, including the null-terminating character.
-if dest != NULL, the return value specifies the number of 16-bit characters that
-  are written to the dest, including the null-terminating character. */
-
-size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest);
-
-/*
-size_t SzArEx_GetFullNameLen(const CSzArEx *p, size_t fileIndex);
-UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16 *dest);
-*/
-
-
-
-/*
-  SzArEx_Extract extracts file from archive
-
-  *outBuffer must be 0 before first call for each new archive.
-
-  Extracting cache:
-    If you need to decompress more than one file, you can send
-    these values from previous call:
-      *blockIndex,
-      *outBuffer,
-      *outBufferSize
-    You can consider "*outBuffer" as cache of solid block. If your archive is solid,
-    it will increase decompression speed.
-  
-    If you use external function, you can declare these 3 cache variables
-    (blockIndex, outBuffer, outBufferSize) as static in that external function.
-    
-    Free *outBuffer and set *outBuffer to 0, if you want to flush cache.
-*/
-
-SRes SzArEx_Extract(
-    const CSzArEx *db,
-    ILookInStream *inStream,
-    UInt32 fileIndex,         /* index of file */
-    UInt32 *blockIndex,       /* index of solid block */
-    Byte **outBuffer,         /* pointer to pointer to output buffer (allocated with allocMain) */
-    size_t *outBufferSize,    /* buffer size for output buffer */
-    size_t *offset,           /* offset of stream for required file in *outBuffer */
-    size_t *outSizeProcessed, /* size of file in *outBuffer */
-    ISzAllocPtr allocMain,
-    ISzAllocPtr allocTemp);
-
-
-/*
-SzArEx_Open Errors:
-SZ_ERROR_NO_ARCHIVE
-SZ_ERROR_ARCHIVE
-SZ_ERROR_UNSUPPORTED
-SZ_ERROR_MEM
-SZ_ERROR_CRC
-SZ_ERROR_INPUT_EOF
-SZ_ERROR_FAIL
-*/
-
-SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream,
-    ISzAllocPtr allocMain, ISzAllocPtr allocTemp);
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/7zAlloc.c

@@ -1,80 +0,0 @@
-/* 7zAlloc.c -- Allocation functions
-2017-04-03 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include <stdlib.h>
-
-#include "7zAlloc.h"
-
-/* #define _SZ_ALLOC_DEBUG */
-/* use _SZ_ALLOC_DEBUG to debug alloc/free operations */
-
-#ifdef _SZ_ALLOC_DEBUG
-
-#ifdef _WIN32
-#include <windows.h>
-#endif
-
-#include <stdio.h>
-int g_allocCount = 0;
-int g_allocCountTemp = 0;
-
-#endif
-
-void *SzAlloc(ISzAllocPtr p, size_t size)
-{
-  UNUSED_VAR(p);
-  if (size == 0)
-    return 0;
-  #ifdef _SZ_ALLOC_DEBUG
-  fprintf(stderr, "\nAlloc %10u bytes; count = %10d", (unsigned)size, g_allocCount);
-  g_allocCount++;
-  #endif
-  return malloc(size);
-}
-
-void SzFree(ISzAllocPtr p, void *address)
-{
-  UNUSED_VAR(p);
-  #ifdef _SZ_ALLOC_DEBUG
-  if (address != 0)
-  {
-    g_allocCount--;
-    fprintf(stderr, "\nFree; count = %10d", g_allocCount);
-  }
-  #endif
-  free(address);
-}
-
-void *SzAllocTemp(ISzAllocPtr p, size_t size)
-{
-  UNUSED_VAR(p);
-  if (size == 0)
-    return 0;
-  #ifdef _SZ_ALLOC_DEBUG
-  fprintf(stderr, "\nAlloc_temp %10u bytes;  count = %10d", (unsigned)size, g_allocCountTemp);
-  g_allocCountTemp++;
-  #ifdef _WIN32
-  return HeapAlloc(GetProcessHeap(), 0, size);
-  #endif
-  #endif
-  return malloc(size);
-}
-
-void SzFreeTemp(ISzAllocPtr p, void *address)
-{
-  UNUSED_VAR(p);
-  #ifdef _SZ_ALLOC_DEBUG
-  if (address != 0)
-  {
-    g_allocCountTemp--;
-    fprintf(stderr, "\nFree_temp; count = %10d", g_allocCountTemp);
-  }
-  #ifdef _WIN32
-  HeapFree(GetProcessHeap(), 0, address);
-  return;
-  #endif
-  #endif
-  free(address);
-}

3rdparty/7z/src/7zAlloc.h

@@ -1,19 +0,0 @@
-/* 7zAlloc.h -- Allocation functions
-2017-04-03 : Igor Pavlov : Public domain */
-
-#ifndef __7Z_ALLOC_H
-#define __7Z_ALLOC_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-void *SzAlloc(ISzAllocPtr p, size_t size);
-void SzFree(ISzAllocPtr p, void *address);
-
-void *SzAllocTemp(ISzAllocPtr p, size_t size);
-void SzFreeTemp(ISzAllocPtr p, void *address);
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/7zBuf.c

@@ -1,36 +0,0 @@
-/* 7zBuf.c -- Byte Buffer
-2017-04-03 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "7zBuf.h"
-
-void Buf_Init(CBuf *p)
-{
-  p->data = 0;
-  p->size = 0;
-}
-
-int Buf_Create(CBuf *p, size_t size, ISzAllocPtr alloc)
-{
-  p->size = 0;
-  if (size == 0)
-  {
-    p->data = 0;
-    return 1;
-  }
-  p->data = (Byte *)ISzAlloc_Alloc(alloc, size);
-  if (p->data)
-  {
-    p->size = size;
-    return 1;
-  }
-  return 0;
-}
-
-void Buf_Free(CBuf *p, ISzAllocPtr alloc)
-{
-  ISzAlloc_Free(alloc, p->data);
-  p->data = 0;
-  p->size = 0;
-}

3rdparty/7z/src/7zBuf.h

@@ -1,35 +0,0 @@
-/* 7zBuf.h -- Byte Buffer
-2017-04-03 : Igor Pavlov : Public domain */
-
-#ifndef __7Z_BUF_H
-#define __7Z_BUF_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-typedef struct
-{
-  Byte *data;
-  size_t size;
-} CBuf;
-
-void Buf_Init(CBuf *p);
-int Buf_Create(CBuf *p, size_t size, ISzAllocPtr alloc);
-void Buf_Free(CBuf *p, ISzAllocPtr alloc);
-
-typedef struct
-{
-  Byte *data;
-  size_t size;
-  size_t pos;
-} CDynBuf;
-
-void DynBuf_Construct(CDynBuf *p);
-void DynBuf_SeekToBeg(CDynBuf *p);
-int DynBuf_Write(CDynBuf *p, const Byte *buf, size_t size, ISzAllocPtr alloc);
-void DynBuf_Free(CDynBuf *p, ISzAllocPtr alloc);
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/7zBuf2.c

@@ -1,52 +0,0 @@
-/* 7zBuf2.c -- Byte Buffer
-2017-04-03 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include <string.h>
-
-#include "7zBuf.h"
-
-void DynBuf_Construct(CDynBuf *p)
-{
-  p->data = 0;
-  p->size = 0;
-  p->pos = 0;
-}
-
-void DynBuf_SeekToBeg(CDynBuf *p)
-{
-  p->pos = 0;
-}
-
-int DynBuf_Write(CDynBuf *p, const Byte *buf, size_t size, ISzAllocPtr alloc)
-{
-  if (size > p->size - p->pos)
-  {
-    size_t newSize = p->pos + size;
-    Byte *data;
-    newSize += newSize / 4;
-    data = (Byte *)ISzAlloc_Alloc(alloc, newSize);
-    if (!data)
-      return 0;
-    p->size = newSize;
-    if (p->pos != 0)
-      memcpy(data, p->data, p->pos);
-    ISzAlloc_Free(alloc, p->data);
-    p->data = data;
-  }
-  if (size != 0)
-  {
-    memcpy(p->data + p->pos, buf, size);
-    p->pos += size;
-  }
-  return 1;
-}
-
-void DynBuf_Free(CDynBuf *p, ISzAllocPtr alloc)
-{
-  ISzAlloc_Free(alloc, p->data);
-  p->data = 0;
-  p->size = 0;
-  p->pos = 0;
-}

3rdparty/7z/src/7zCrc.c

@@ -1,322 +0,0 @@
-/* 7zCrc.c -- CRC32 init
-2021-04-01 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "7zCrc.h"
-#include "CpuArch.h"
-
-#define kCrcPoly 0xEDB88320
-
-#ifdef MY_CPU_LE
-  #define CRC_NUM_TABLES 8
-#else
-  #define CRC_NUM_TABLES 9
-
-  #define CRC_UINT32_SWAP(v) ((v >> 24) | ((v >> 8) & 0xFF00) | ((v << 8) & 0xFF0000) | (v << 24))
-
-  UInt32 MY_FAST_CALL CrcUpdateT1_BeT4(UInt32 v, const void *data, size_t size, const UInt32 *table);
-  UInt32 MY_FAST_CALL CrcUpdateT1_BeT8(UInt32 v, const void *data, size_t size, const UInt32 *table);
-#endif
-
-#ifndef MY_CPU_BE
-  UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table);
-  UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table);
-#endif
-
-typedef UInt32 (MY_FAST_CALL *CRC_FUNC)(UInt32 v, const void *data, size_t size, const UInt32 *table);
-
-extern
-CRC_FUNC g_CrcUpdateT4;
-CRC_FUNC g_CrcUpdateT4;
-extern
-CRC_FUNC g_CrcUpdateT8;
-CRC_FUNC g_CrcUpdateT8;
-extern
-CRC_FUNC g_CrcUpdateT0_32;
-CRC_FUNC g_CrcUpdateT0_32;
-extern
-CRC_FUNC g_CrcUpdateT0_64;
-CRC_FUNC g_CrcUpdateT0_64;
-extern
-CRC_FUNC g_CrcUpdate;
-CRC_FUNC g_CrcUpdate;
-
-UInt32 g_CrcTable[256 * CRC_NUM_TABLES];
-
-UInt32 MY_FAST_CALL CrcUpdate(UInt32 v, const void *data, size_t size)
-{
-  return g_CrcUpdate(v, data, size, g_CrcTable);
-}
-
-UInt32 MY_FAST_CALL CrcCalc(const void *data, size_t size)
-{
-  return g_CrcUpdate(CRC_INIT_VAL, data, size, g_CrcTable) ^ CRC_INIT_VAL;
-}
-
-#define CRC_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
-
-UInt32 MY_FAST_CALL CrcUpdateT1(UInt32 v, const void *data, size_t size, const UInt32 *table);
-UInt32 MY_FAST_CALL CrcUpdateT1(UInt32 v, const void *data, size_t size, const UInt32 *table)
-{
-  const Byte *p = (const Byte *)data;
-  const Byte *pEnd = p + size;
-  for (; p != pEnd; p++)
-    v = CRC_UPDATE_BYTE_2(v, *p);
-  return v;
-}
-
-
-/* ---------- hardware CRC ---------- */
-
-#ifdef MY_CPU_LE
-
-#if defined(MY_CPU_ARM_OR_ARM64)
-
-// #pragma message("ARM*")
-
-  #if defined(_MSC_VER)
-    #if defined(MY_CPU_ARM64)
-    #if (_MSC_VER >= 1910)
-        #define USE_ARM64_CRC
-    #endif
-    #endif
-  #elif (defined(__clang__) && (__clang_major__ >= 3)) \
-     || (defined(__GNUC__) && (__GNUC__ > 4))
-      #if !defined(__ARM_FEATURE_CRC32)
-        #define __ARM_FEATURE_CRC32 1
-          #if (!defined(__clang__) || (__clang_major__ > 3)) // fix these numbers
-            #define ATTRIB_CRC __attribute__((__target__("arch=armv8-a+crc")))
-          #endif
-      #endif
-      #if defined(__ARM_FEATURE_CRC32)
-        #define USE_ARM64_CRC
-        #include <arm_acle.h>
-      #endif
-  #endif
-
-#else
-
-// no hardware CRC
-
-// #define USE_CRC_EMU
-
-#ifdef USE_CRC_EMU
-
-#pragma message("ARM64 CRC emulation")
-
-MY_FORCE_INLINE
-UInt32 __crc32b(UInt32 v, UInt32 data)
-{
-  const UInt32 *table = g_CrcTable;
-  v = CRC_UPDATE_BYTE_2(v, (Byte)data);
-  return v;
-}
-
-MY_FORCE_INLINE
-UInt32 __crc32w(UInt32 v, UInt32 data)
-{
-  const UInt32 *table = g_CrcTable;
-  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
-  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
-  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
-  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
-  return v;
-}
-
-MY_FORCE_INLINE
-UInt32 __crc32d(UInt32 v, UInt64 data)
-{
-  const UInt32 *table = g_CrcTable;
-  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
-  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
-  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
-  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
-  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
-  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
-  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
-  v = CRC_UPDATE_BYTE_2(v, (Byte)data); data >>= 8;
-  return v;
-}
-
-#endif // USE_CRC_EMU
-
-#endif // defined(MY_CPU_ARM64) && defined(MY_CPU_LE)
-
-
-
-#if defined(USE_ARM64_CRC) || defined(USE_CRC_EMU)
-
-#define T0_32_UNROLL_BYTES (4 * 4)
-#define T0_64_UNROLL_BYTES (4 * 8)
-
-#ifndef ATTRIB_CRC
-#define ATTRIB_CRC
-#endif
-// #pragma message("USE ARM HW CRC")
-
-ATTRIB_CRC
-UInt32 MY_FAST_CALL CrcUpdateT0_32(UInt32 v, const void *data, size_t size, const UInt32 *table);
-ATTRIB_CRC
-UInt32 MY_FAST_CALL CrcUpdateT0_32(UInt32 v, const void *data, size_t size, const UInt32 *table)
-{
-  const Byte *p = (const Byte *)data;
-  UNUSED_VAR(table);
-
-  for (; size != 0 && ((unsigned)(ptrdiff_t)p & (T0_32_UNROLL_BYTES - 1)) != 0; size--)
-    v = __crc32b(v, *p++);
-
-  if (size >= T0_32_UNROLL_BYTES)
-  {
-    const Byte *lim = p + size;
-    size &= (T0_32_UNROLL_BYTES - 1);
-    lim -= size;
-    do
-    {
-      v = __crc32w(v, *(const UInt32 *)(const void *)(p));
-      v = __crc32w(v, *(const UInt32 *)(const void *)(p + 4)); p += 2 * 4;
-      v = __crc32w(v, *(const UInt32 *)(const void *)(p));
-      v = __crc32w(v, *(const UInt32 *)(const void *)(p + 4)); p += 2 * 4;
-    }
-    while (p != lim);
-  }
-  
-  for (; size != 0; size--)
-    v = __crc32b(v, *p++);
-
-  return v;
-}
-
-ATTRIB_CRC
-UInt32 MY_FAST_CALL CrcUpdateT0_64(UInt32 v, const void *data, size_t size, const UInt32 *table);
-ATTRIB_CRC
-UInt32 MY_FAST_CALL CrcUpdateT0_64(UInt32 v, const void *data, size_t size, const UInt32 *table)
-{
-  const Byte *p = (const Byte *)data;
-  UNUSED_VAR(table);
-
-  for (; size != 0 && ((unsigned)(ptrdiff_t)p & (T0_64_UNROLL_BYTES - 1)) != 0; size--)
-    v = __crc32b(v, *p++);
-
-  if (size >= T0_64_UNROLL_BYTES)
-  {
-    const Byte *lim = p + size;
-    size &= (T0_64_UNROLL_BYTES - 1);
-    lim -= size;
-    do
-    {
-      v = __crc32d(v, *(const UInt64 *)(const void *)(p));
-      v = __crc32d(v, *(const UInt64 *)(const void *)(p + 8)); p += 2 * 8;
-      v = __crc32d(v, *(const UInt64 *)(const void *)(p));
-      v = __crc32d(v, *(const UInt64 *)(const void *)(p + 8)); p += 2 * 8;
-    }
-    while (p != lim);
-  }
-  
-  for (; size != 0; size--)
-    v = __crc32b(v, *p++);
-
-  return v;
-}
-
-#endif // defined(USE_ARM64_CRC) || defined(USE_CRC_EMU)
-
-#endif // MY_CPU_LE
-
-
-
-
-void MY_FAST_CALL CrcGenerateTable()
-{
-  UInt32 i;
-  for (i = 0; i < 256; i++)
-  {
-    UInt32 r = i;
-    unsigned j;
-    for (j = 0; j < 8; j++)
-      r = (r >> 1) ^ (kCrcPoly & ((UInt32)0 - (r & 1)));
-    g_CrcTable[i] = r;
-  }
-  for (i = 256; i < 256 * CRC_NUM_TABLES; i++)
-  {
-    UInt32 r = g_CrcTable[(size_t)i - 256];
-    g_CrcTable[i] = g_CrcTable[r & 0xFF] ^ (r >> 8);
-  }
-
-  #if CRC_NUM_TABLES < 4
-  
-  g_CrcUpdate = CrcUpdateT1;
-  
-  #else
- 
-  #ifdef MY_CPU_LE
-
-    g_CrcUpdateT4 = CrcUpdateT4;
-    g_CrcUpdate = CrcUpdateT4;
-
-    #if CRC_NUM_TABLES >= 8
-      g_CrcUpdateT8 = CrcUpdateT8;
-  
-      #ifdef MY_CPU_X86_OR_AMD64
-      if (!CPU_Is_InOrder())
-      #endif
-        g_CrcUpdate = CrcUpdateT8;
-    #endif
-
-  #else
-  {
-    #ifndef MY_CPU_BE
-    UInt32 k = 0x01020304;
-    const Byte *p = (const Byte *)&k;
-    if (p[0] == 4 && p[1] == 3)
-    {
-      g_CrcUpdateT4 = CrcUpdateT4;
-      g_CrcUpdate = CrcUpdateT4;
-      #if CRC_NUM_TABLES >= 8
-      g_CrcUpdateT8 = CrcUpdateT8;
-      g_CrcUpdate = CrcUpdateT8;
-      #endif
-    }
-    else if (p[0] != 1 || p[1] != 2)
-      g_CrcUpdate = CrcUpdateT1;
-    else
-    #endif
-    {
-      for (i = 256 * CRC_NUM_TABLES - 1; i >= 256; i--)
-      {
-        UInt32 x = g_CrcTable[(size_t)i - 256];
-        g_CrcTable[i] = CRC_UINT32_SWAP(x);
-      }
-      g_CrcUpdateT4 = CrcUpdateT1_BeT4;
-      g_CrcUpdate = CrcUpdateT1_BeT4;
-      #if CRC_NUM_TABLES >= 8
-      g_CrcUpdateT8 = CrcUpdateT1_BeT8;
-      g_CrcUpdate = CrcUpdateT1_BeT8;
-      #endif
-    }
-  }
-  #endif
-  #endif
-
-  #ifdef MY_CPU_LE
-    #ifdef USE_ARM64_CRC
-      if (CPU_IsSupported_CRC32())
-      {
-        g_CrcUpdateT0_32 = CrcUpdateT0_32;
-        g_CrcUpdateT0_64 = CrcUpdateT0_64;
-        g_CrcUpdate =
-          #if defined(MY_CPU_ARM)
-            CrcUpdateT0_32;
-          #else
-            CrcUpdateT0_64;
-          #endif
-      }
-    #endif
-    
-    #ifdef USE_CRC_EMU
-      g_CrcUpdateT0_32 = CrcUpdateT0_32;
-      g_CrcUpdateT0_64 = CrcUpdateT0_64;
-      g_CrcUpdate = CrcUpdateT0_64;
-    #endif
-  #endif
-}

3rdparty/7z/src/7zCrc.h

@@ -1,25 +0,0 @@
-/* 7zCrc.h -- CRC32 calculation
-2013-01-18 : Igor Pavlov : Public domain */
-
-#ifndef __7Z_CRC_H
-#define __7Z_CRC_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-extern UInt32 g_CrcTable[];
-
-/* Call CrcGenerateTable one time before other CRC functions */
-void MY_FAST_CALL CrcGenerateTable(void);
-
-#define CRC_INIT_VAL 0xFFFFFFFF
-#define CRC_GET_DIGEST(crc) ((crc) ^ CRC_INIT_VAL)
-#define CRC_UPDATE_BYTE(crc, b) (g_CrcTable[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
-
-UInt32 MY_FAST_CALL CrcUpdate(UInt32 crc, const void *data, size_t size);
-UInt32 MY_FAST_CALL CrcCalc(const void *data, size_t size);
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/7zCrcOpt.c

@@ -1,117 +0,0 @@
-/* 7zCrcOpt.c -- CRC32 calculation
-2021-02-09 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "CpuArch.h"
-
-#ifndef MY_CPU_BE
-
-#define CRC_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
-
-UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table);
-UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table)
-{
-  const Byte *p = (const Byte *)data;
-  for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++)
-    v = CRC_UPDATE_BYTE_2(v, *p);
-  for (; size >= 4; size -= 4, p += 4)
-  {
-    v ^= *(const UInt32 *)(const void *)p;
-    v =
-          (table + 0x300)[((v      ) & 0xFF)]
-        ^ (table + 0x200)[((v >>  8) & 0xFF)]
-        ^ (table + 0x100)[((v >> 16) & 0xFF)]
-        ^ (table + 0x000)[((v >> 24))];
-  }
-  for (; size > 0; size--, p++)
-    v = CRC_UPDATE_BYTE_2(v, *p);
-  return v;
-}
-
-UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table);
-UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table)
-{
-  const Byte *p = (const Byte *)data;
-  for (; size > 0 && ((unsigned)(ptrdiff_t)p & 7) != 0; size--, p++)
-    v = CRC_UPDATE_BYTE_2(v, *p);
-  for (; size >= 8; size -= 8, p += 8)
-  {
-    UInt32 d;
-    v ^= *(const UInt32 *)(const void *)p;
-    v =
-          (table + 0x700)[((v      ) & 0xFF)]
-        ^ (table + 0x600)[((v >>  8) & 0xFF)]
-        ^ (table + 0x500)[((v >> 16) & 0xFF)]
-        ^ (table + 0x400)[((v >> 24))];
-    d = *((const UInt32 *)(const void *)p + 1);
-    v ^=
-          (table + 0x300)[((d      ) & 0xFF)]
-        ^ (table + 0x200)[((d >>  8) & 0xFF)]
-        ^ (table + 0x100)[((d >> 16) & 0xFF)]
-        ^ (table + 0x000)[((d >> 24))];
-  }
-  for (; size > 0; size--, p++)
-    v = CRC_UPDATE_BYTE_2(v, *p);
-  return v;
-}
-
-#endif
-
-
-#ifndef MY_CPU_LE
-
-#define CRC_UINT32_SWAP(v) ((v >> 24) | ((v >> 8) & 0xFF00) | ((v << 8) & 0xFF0000) | (v << 24))
-
-#define CRC_UPDATE_BYTE_2_BE(crc, b) (table[(((crc) >> 24) ^ (b))] ^ ((crc) << 8))
-
-UInt32 MY_FAST_CALL CrcUpdateT1_BeT4(UInt32 v, const void *data, size_t size, const UInt32 *table)
-{
-  const Byte *p = (const Byte *)data;
-  table += 0x100;
-  v = CRC_UINT32_SWAP(v);
-  for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++)
-    v = CRC_UPDATE_BYTE_2_BE(v, *p);
-  for (; size >= 4; size -= 4, p += 4)
-  {
-    v ^= *(const UInt32 *)(const void *)p;
-    v =
-          (table + 0x000)[((v      ) & 0xFF)]
-        ^ (table + 0x100)[((v >>  8) & 0xFF)]
-        ^ (table + 0x200)[((v >> 16) & 0xFF)]
-        ^ (table + 0x300)[((v >> 24))];
-  }
-  for (; size > 0; size--, p++)
-    v = CRC_UPDATE_BYTE_2_BE(v, *p);
-  return CRC_UINT32_SWAP(v);
-}
-
-UInt32 MY_FAST_CALL CrcUpdateT1_BeT8(UInt32 v, const void *data, size_t size, const UInt32 *table)
-{
-  const Byte *p = (const Byte *)data;
-  table += 0x100;
-  v = CRC_UINT32_SWAP(v);
-  for (; size > 0 && ((unsigned)(ptrdiff_t)p & 7) != 0; size--, p++)
-    v = CRC_UPDATE_BYTE_2_BE(v, *p);
-  for (; size >= 8; size -= 8, p += 8)
-  {
-    UInt32 d;
-    v ^= *(const UInt32 *)(const void *)p;
-    v =
-          (table + 0x400)[((v      ) & 0xFF)]
-        ^ (table + 0x500)[((v >>  8) & 0xFF)]
-        ^ (table + 0x600)[((v >> 16) & 0xFF)]
-        ^ (table + 0x700)[((v >> 24))];
-    d = *((const UInt32 *)(const void *)p + 1);
-    v ^=
-          (table + 0x000)[((d      ) & 0xFF)]
-        ^ (table + 0x100)[((d >>  8) & 0xFF)]
-        ^ (table + 0x200)[((d >> 16) & 0xFF)]
-        ^ (table + 0x300)[((d >> 24))];
-  }
-  for (; size > 0; size--, p++)
-    v = CRC_UPDATE_BYTE_2_BE(v, *p);
-  return CRC_UINT32_SWAP(v);
-}
-
-#endif

3rdparty/7z/src/7zDec.c

@@ -1,600 +0,0 @@
-/* 7zDec.c -- Decoding from 7z folder
-2021-02-09 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include <string.h>
-
-/* #define _7ZIP_PPMD_SUPPPORT */
-
-#include "7z.h"
-#include "7zCrc.h"
-
-#include "Bcj2.h"
-#include "Bra.h"
-#include "CpuArch.h"
-#include "Delta.h"
-#include "LzmaDec.h"
-#include "Lzma2Dec.h"
-#ifdef _7ZIP_PPMD_SUPPPORT
-#include "Ppmd7.h"
-#endif
-
-#define k_Copy 0
-#ifndef _7Z_NO_METHOD_LZMA2
-#define k_LZMA2 0x21
-#endif
-#define k_LZMA  0x30101
-#define k_BCJ2  0x303011B
-#ifndef _7Z_NO_METHODS_FILTERS
-#define k_Delta 3
-#define k_BCJ   0x3030103
-#define k_PPC   0x3030205
-#define k_IA64  0x3030401
-#define k_ARM   0x3030501
-#define k_ARMT  0x3030701
-#define k_SPARC 0x3030805
-#endif
-
-#ifdef _7ZIP_PPMD_SUPPPORT
-
-#define k_PPMD 0x30401
-
-typedef struct
-{
-  IByteIn vt;
-  const Byte *cur;
-  const Byte *end;
-  const Byte *begin;
-  UInt64 processed;
-  BoolInt extra;
-  SRes res;
-  const ILookInStream *inStream;
-} CByteInToLook;
-
-static Byte ReadByte(const IByteIn *pp)
-{
-  CByteInToLook *p = CONTAINER_FROM_VTBL(pp, CByteInToLook, vt);
-  if (p->cur != p->end)
-    return *p->cur++;
-  if (p->res == SZ_OK)
-  {
-    size_t size = (size_t)(p->cur - p->begin);
-    p->processed += size;
-    p->res = ILookInStream_Skip(p->inStream, size);
-    size = (1 << 25);
-    p->res = ILookInStream_Look(p->inStream, (const void **)&p->begin, &size);
-    p->cur = p->begin;
-    p->end = p->begin + size;
-    if (size != 0)
-      return *p->cur++;;
-  }
-  p->extra = True;
-  return 0;
-}
-
-static SRes SzDecodePpmd(const Byte *props, unsigned propsSize, UInt64 inSize, const ILookInStream *inStream,
-    Byte *outBuffer, SizeT outSize, ISzAllocPtr allocMain)
-{
-  CPpmd7 ppmd;
-  CByteInToLook s;
-  SRes res = SZ_OK;
-
-  s.vt.Read = ReadByte;
-  s.inStream = inStream;
-  s.begin = s.end = s.cur = NULL;
-  s.extra = False;
-  s.res = SZ_OK;
-  s.processed = 0;
-
-  if (propsSize != 5)
-    return SZ_ERROR_UNSUPPORTED;
-
-  {
-    unsigned order = props[0];
-    UInt32 memSize = GetUi32(props + 1);
-    if (order < PPMD7_MIN_ORDER ||
-        order > PPMD7_MAX_ORDER ||
-        memSize < PPMD7_MIN_MEM_SIZE ||
-        memSize > PPMD7_MAX_MEM_SIZE)
-      return SZ_ERROR_UNSUPPORTED;
-    Ppmd7_Construct(&ppmd);
-    if (!Ppmd7_Alloc(&ppmd, memSize, allocMain))
-      return SZ_ERROR_MEM;
-    Ppmd7_Init(&ppmd, order);
-  }
-  {
-    ppmd.rc.dec.Stream = &s.vt;
-    if (!Ppmd7z_RangeDec_Init(&ppmd.rc.dec))
-      res = SZ_ERROR_DATA;
-    else if (!s.extra)
-    {
-      Byte *buf = outBuffer;
-      const Byte *lim = buf + outSize;
-      for (; buf != lim; buf++)
-      {
-        int sym = Ppmd7z_DecodeSymbol(&ppmd);
-        if (s.extra || sym < 0)
-          break;
-        *buf = (Byte)sym;
-      }
-      if (buf != lim)
-        res = SZ_ERROR_DATA;
-      else if (!Ppmd7z_RangeDec_IsFinishedOK(&ppmd.rc.dec))
-      {
-        /* if (Ppmd7z_DecodeSymbol(&ppmd) != PPMD7_SYM_END || !Ppmd7z_RangeDec_IsFinishedOK(&ppmd.rc.dec)) */
-        res = SZ_ERROR_DATA;
-      }
-    }
-    if (s.extra)
-      res = (s.res != SZ_OK ? s.res : SZ_ERROR_DATA);
-    else if (s.processed + (size_t)(s.cur - s.begin) != inSize)
-      res = SZ_ERROR_DATA;
-  }
-  Ppmd7_Free(&ppmd, allocMain);
-  return res;
-}
-
-#endif
-
-
-static SRes SzDecodeLzma(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStream *inStream,
-    Byte *outBuffer, SizeT outSize, ISzAllocPtr allocMain)
-{
-  CLzmaDec state;
-  SRes res = SZ_OK;
-
-  LzmaDec_Construct(&state);
-  RINOK(LzmaDec_AllocateProbs(&state, props, propsSize, allocMain));
-  state.dic = outBuffer;
-  state.dicBufSize = outSize;
-  LzmaDec_Init(&state);
-
-  for (;;)
-  {
-    const void *inBuf = NULL;
-    size_t lookahead = (1 << 18);
-    if (lookahead > inSize)
-      lookahead = (size_t)inSize;
-    res = ILookInStream_Look(inStream, &inBuf, &lookahead);
-    if (res != SZ_OK)
-      break;
-
-    {
-      SizeT inProcessed = (SizeT)lookahead, dicPos = state.dicPos;
-      ELzmaStatus status;
-      res = LzmaDec_DecodeToDic(&state, outSize, (const Byte *)inBuf, &inProcessed, LZMA_FINISH_END, &status);
-      lookahead -= inProcessed;
-      inSize -= inProcessed;
-      if (res != SZ_OK)
-        break;
-
-      if (status == LZMA_STATUS_FINISHED_WITH_MARK)
-      {
-        if (outSize != state.dicPos || inSize != 0)
-          res = SZ_ERROR_DATA;
-        break;
-      }
-
-      if (outSize == state.dicPos && inSize == 0 && status == LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK)
-        break;
-
-      if (inProcessed == 0 && dicPos == state.dicPos)
-      {
-        res = SZ_ERROR_DATA;
-        break;
-      }
-
-      res = ILookInStream_Skip(inStream, inProcessed);
-      if (res != SZ_OK)
-        break;
-    }
-  }
-
-  LzmaDec_FreeProbs(&state, allocMain);
-  return res;
-}
-
-
-#ifndef _7Z_NO_METHOD_LZMA2
-
-static SRes SzDecodeLzma2(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStream *inStream,
-    Byte *outBuffer, SizeT outSize, ISzAllocPtr allocMain)
-{
-  CLzma2Dec state;
-  SRes res = SZ_OK;
-
-  Lzma2Dec_Construct(&state);
-  if (propsSize != 1)
-    return SZ_ERROR_DATA;
-  RINOK(Lzma2Dec_AllocateProbs(&state, props[0], allocMain));
-  state.decoder.dic = outBuffer;
-  state.decoder.dicBufSize = outSize;
-  Lzma2Dec_Init(&state);
-
-  for (;;)
-  {
-    const void *inBuf = NULL;
-    size_t lookahead = (1 << 18);
-    if (lookahead > inSize)
-      lookahead = (size_t)inSize;
-    res = ILookInStream_Look(inStream, &inBuf, &lookahead);
-    if (res != SZ_OK)
-      break;
-
-    {
-      SizeT inProcessed = (SizeT)lookahead, dicPos = state.decoder.dicPos;
-      ELzmaStatus status;
-      res = Lzma2Dec_DecodeToDic(&state, outSize, (const Byte *)inBuf, &inProcessed, LZMA_FINISH_END, &status);
-      lookahead -= inProcessed;
-      inSize -= inProcessed;
-      if (res != SZ_OK)
-        break;
-
-      if (status == LZMA_STATUS_FINISHED_WITH_MARK)
-      {
-        if (outSize != state.decoder.dicPos || inSize != 0)
-          res = SZ_ERROR_DATA;
-        break;
-      }
-
-      if (inProcessed == 0 && dicPos == state.decoder.dicPos)
-      {
-        res = SZ_ERROR_DATA;
-        break;
-      }
-
-      res = ILookInStream_Skip(inStream, inProcessed);
-      if (res != SZ_OK)
-        break;
-    }
-  }
-
-  Lzma2Dec_FreeProbs(&state, allocMain);
-  return res;
-}
-
-#endif
-
-
-static SRes SzDecodeCopy(UInt64 inSize, ILookInStream *inStream, Byte *outBuffer)
-{
-  while (inSize > 0)
-  {
-    const void *inBuf;
-    size_t curSize = (1 << 18);
-    if (curSize > inSize)
-      curSize = (size_t)inSize;
-    RINOK(ILookInStream_Look(inStream, &inBuf, &curSize));
-    if (curSize == 0)
-      return SZ_ERROR_INPUT_EOF;
-    memcpy(outBuffer, inBuf, curSize);
-    outBuffer += curSize;
-    inSize -= curSize;
-    RINOK(ILookInStream_Skip(inStream, curSize));
-  }
-  return SZ_OK;
-}
-
-static BoolInt IS_MAIN_METHOD(UInt32 m)
-{
-  switch (m)
-  {
-    case k_Copy:
-    case k_LZMA:
-    #ifndef _7Z_NO_METHOD_LZMA2
-    case k_LZMA2:
-    #endif
-    #ifdef _7ZIP_PPMD_SUPPPORT
-    case k_PPMD:
-    #endif
-      return True;
-  }
-  return False;
-}
-
-static BoolInt IS_SUPPORTED_CODER(const CSzCoderInfo *c)
-{
-  return
-      c->NumStreams == 1
-      /* && c->MethodID <= (UInt32)0xFFFFFFFF */
-      && IS_MAIN_METHOD((UInt32)c->MethodID);
-}
-
-#define IS_BCJ2(c) ((c)->MethodID == k_BCJ2 && (c)->NumStreams == 4)
-
-static SRes CheckSupportedFolder(const CSzFolder *f)
-{
-  if (f->NumCoders < 1 || f->NumCoders > 4)
-    return SZ_ERROR_UNSUPPORTED;
-  if (!IS_SUPPORTED_CODER(&f->Coders[0]))
-    return SZ_ERROR_UNSUPPORTED;
-  if (f->NumCoders == 1)
-  {
-    if (f->NumPackStreams != 1 || f->PackStreams[0] != 0 || f->NumBonds != 0)
-      return SZ_ERROR_UNSUPPORTED;
-    return SZ_OK;
-  }
-  
-  
-  #ifndef _7Z_NO_METHODS_FILTERS
-
-  if (f->NumCoders == 2)
-  {
-    const CSzCoderInfo *c = &f->Coders[1];
-    if (
-        /* c->MethodID > (UInt32)0xFFFFFFFF || */
-        c->NumStreams != 1
-        || f->NumPackStreams != 1
-        || f->PackStreams[0] != 0
-        || f->NumBonds != 1
-        || f->Bonds[0].InIndex != 1
-        || f->Bonds[0].OutIndex != 0)
-      return SZ_ERROR_UNSUPPORTED;
-    switch ((UInt32)c->MethodID)
-    {
-      case k_Delta:
-      case k_BCJ:
-      case k_PPC:
-      case k_IA64:
-      case k_SPARC:
-      case k_ARM:
-      case k_ARMT:
-        break;
-      default:
-        return SZ_ERROR_UNSUPPORTED;
-    }
-    return SZ_OK;
-  }
-
-  #endif
-
-  
-  if (f->NumCoders == 4)
-  {
-    if (!IS_SUPPORTED_CODER(&f->Coders[1])
-        || !IS_SUPPORTED_CODER(&f->Coders[2])
-        || !IS_BCJ2(&f->Coders[3]))
-      return SZ_ERROR_UNSUPPORTED;
-    if (f->NumPackStreams != 4
-        || f->PackStreams[0] != 2
-        || f->PackStreams[1] != 6
-        || f->PackStreams[2] != 1
-        || f->PackStreams[3] != 0
-        || f->NumBonds != 3
-        || f->Bonds[0].InIndex != 5 || f->Bonds[0].OutIndex != 0
-        || f->Bonds[1].InIndex != 4 || f->Bonds[1].OutIndex != 1
-        || f->Bonds[2].InIndex != 3 || f->Bonds[2].OutIndex != 2)
-      return SZ_ERROR_UNSUPPORTED;
-    return SZ_OK;
-  }
-  
-  return SZ_ERROR_UNSUPPORTED;
-}
-
-#ifndef _7Z_NO_METHODS_FILTERS
-#define CASE_BRA_CONV(isa) case k_ ## isa: isa ## _Convert(outBuffer, outSize, 0, 0); break;
-#endif
-
-static SRes SzFolder_Decode2(const CSzFolder *folder,
-    const Byte *propsData,
-    const UInt64 *unpackSizes,
-    const UInt64 *packPositions,
-    ILookInStream *inStream, UInt64 startPos,
-    Byte *outBuffer, SizeT outSize, ISzAllocPtr allocMain,
-    Byte *tempBuf[])
-{
-  UInt32 ci;
-  SizeT tempSizes[3] = { 0, 0, 0};
-  SizeT tempSize3 = 0;
-  Byte *tempBuf3 = 0;
-
-  RINOK(CheckSupportedFolder(folder));
-
-  for (ci = 0; ci < folder->NumCoders; ci++)
-  {
-    const CSzCoderInfo *coder = &folder->Coders[ci];
-
-    if (IS_MAIN_METHOD((UInt32)coder->MethodID))
-    {
-      UInt32 si = 0;
-      UInt64 offset;
-      UInt64 inSize;
-      Byte *outBufCur = outBuffer;
-      SizeT outSizeCur = outSize;
-      if (folder->NumCoders == 4)
-      {
-        UInt32 indices[] = { 3, 2, 0 };
-        UInt64 unpackSize = unpackSizes[ci];
-        si = indices[ci];
-        if (ci < 2)
-        {
-          Byte *temp;
-          outSizeCur = (SizeT)unpackSize;
-          if (outSizeCur != unpackSize)
-            return SZ_ERROR_MEM;
-          temp = (Byte *)ISzAlloc_Alloc(allocMain, outSizeCur);
-          if (!temp && outSizeCur != 0)
-            return SZ_ERROR_MEM;
-          outBufCur = tempBuf[1 - ci] = temp;
-          tempSizes[1 - ci] = outSizeCur;
-        }
-        else if (ci == 2)
-        {
-          if (unpackSize > outSize) /* check it */
-            return SZ_ERROR_PARAM;
-          tempBuf3 = outBufCur = outBuffer + (outSize - (size_t)unpackSize);
-          tempSize3 = outSizeCur = (SizeT)unpackSize;
-        }
-        else
-          return SZ_ERROR_UNSUPPORTED;
-      }
-      offset = packPositions[si];
-      inSize = packPositions[(size_t)si + 1] - offset;
-      RINOK(LookInStream_SeekTo(inStream, startPos + offset));
-
-      if (coder->MethodID == k_Copy)
-      {
-        if (inSize != outSizeCur) /* check it */
-          return SZ_ERROR_DATA;
-        RINOK(SzDecodeCopy(inSize, inStream, outBufCur));
-      }
-      else if (coder->MethodID == k_LZMA)
-      {
-        RINOK(SzDecodeLzma(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain));
-      }
-      #ifndef _7Z_NO_METHOD_LZMA2
-      else if (coder->MethodID == k_LZMA2)
-      {
-        RINOK(SzDecodeLzma2(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain));
-      }
-      #endif
-      #ifdef _7ZIP_PPMD_SUPPPORT
-      else if (coder->MethodID == k_PPMD)
-      {
-        RINOK(SzDecodePpmd(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain));
-      }
-      #endif
-      else
-        return SZ_ERROR_UNSUPPORTED;
-    }
-    else if (coder->MethodID == k_BCJ2)
-    {
-      UInt64 offset = packPositions[1];
-      UInt64 s3Size = packPositions[2] - offset;
-      
-      if (ci != 3)
-        return SZ_ERROR_UNSUPPORTED;
-      
-      tempSizes[2] = (SizeT)s3Size;
-      if (tempSizes[2] != s3Size)
-        return SZ_ERROR_MEM;
-      tempBuf[2] = (Byte *)ISzAlloc_Alloc(allocMain, tempSizes[2]);
-      if (!tempBuf[2] && tempSizes[2] != 0)
-        return SZ_ERROR_MEM;
-      
-      RINOK(LookInStream_SeekTo(inStream, startPos + offset));
-      RINOK(SzDecodeCopy(s3Size, inStream, tempBuf[2]));
-
-      if ((tempSizes[0] & 3) != 0 ||
-          (tempSizes[1] & 3) != 0 ||
-          tempSize3 + tempSizes[0] + tempSizes[1] != outSize)
-        return SZ_ERROR_DATA;
-
-      {
-        CBcj2Dec p;
-        
-        p.bufs[0] = tempBuf3;   p.lims[0] = tempBuf3 + tempSize3;
-        p.bufs[1] = tempBuf[0]; p.lims[1] = tempBuf[0] + tempSizes[0];
-        p.bufs[2] = tempBuf[1]; p.lims[2] = tempBuf[1] + tempSizes[1];
-        p.bufs[3] = tempBuf[2]; p.lims[3] = tempBuf[2] + tempSizes[2];
-        
-        p.dest = outBuffer;
-        p.destLim = outBuffer + outSize;
-        
-        Bcj2Dec_Init(&p);
-        RINOK(Bcj2Dec_Decode(&p));
-
-        {
-          unsigned i;
-          for (i = 0; i < 4; i++)
-            if (p.bufs[i] != p.lims[i])
-              return SZ_ERROR_DATA;
-          
-          if (!Bcj2Dec_IsFinished(&p))
-            return SZ_ERROR_DATA;
-
-          if (p.dest != p.destLim
-             || p.state != BCJ2_STREAM_MAIN)
-            return SZ_ERROR_DATA;
-        }
-      }
-    }
-    #ifndef _7Z_NO_METHODS_FILTERS
-    else if (ci == 1)
-    {
-      if (coder->MethodID == k_Delta)
-      {
-        if (coder->PropsSize != 1)
-          return SZ_ERROR_UNSUPPORTED;
-        {
-          Byte state[DELTA_STATE_SIZE];
-          Delta_Init(state);
-          Delta_Decode(state, (unsigned)(propsData[coder->PropsOffset]) + 1, outBuffer, outSize);
-        }
-      }
-      else
-      {
-        if (coder->PropsSize != 0)
-          return SZ_ERROR_UNSUPPORTED;
-        switch (coder->MethodID)
-        {
-          case k_BCJ:
-          {
-            UInt32 state;
-            x86_Convert_Init(state);
-            x86_Convert(outBuffer, outSize, 0, &state, 0);
-            break;
-          }
-          CASE_BRA_CONV(PPC)
-          CASE_BRA_CONV(IA64)
-          CASE_BRA_CONV(SPARC)
-          CASE_BRA_CONV(ARM)
-          CASE_BRA_CONV(ARMT)
-          default:
-            return SZ_ERROR_UNSUPPORTED;
-        }
-      }
-    }
-    #endif
-    else
-      return SZ_ERROR_UNSUPPORTED;
-  }
-
-  return SZ_OK;
-}
-
-
-SRes SzAr_DecodeFolder(const CSzAr *p, UInt32 folderIndex,
-    ILookInStream *inStream, UInt64 startPos,
-    Byte *outBuffer, size_t outSize,
-    ISzAllocPtr allocMain)
-{
-  SRes res;
-  CSzFolder folder;
-  CSzData sd;
-  
-  const Byte *data = p->CodersData + p->FoCodersOffsets[folderIndex];
-  sd.Data = data;
-  sd.Size = p->FoCodersOffsets[(size_t)folderIndex + 1] - p->FoCodersOffsets[folderIndex];
-  
-  res = SzGetNextFolderItem(&folder, &sd);
-  
-  if (res != SZ_OK)
-    return res;
-
-  if (sd.Size != 0
-      || folder.UnpackStream != p->FoToMainUnpackSizeIndex[folderIndex]
-      || outSize != SzAr_GetFolderUnpackSize(p, folderIndex))
-    return SZ_ERROR_FAIL;
-  {
-    unsigned i;
-    Byte *tempBuf[3] = { 0, 0, 0};
-
-    res = SzFolder_Decode2(&folder, data,
-        &p->CoderUnpackSizes[p->FoToCoderUnpackSizes[folderIndex]],
-        p->PackPositions + p->FoStartPackStreamIndex[folderIndex],
-        inStream, startPos,
-        outBuffer, (SizeT)outSize, allocMain, tempBuf);
-    
-    for (i = 0; i < 3; i++)
-      ISzAlloc_Free(allocMain, tempBuf[i]);
-
-    if (res == SZ_OK)
-      if (SzBitWithVals_Check(&p->FolderCRCs, folderIndex))
-        if (CrcCalc(outBuffer, outSize) != p->FolderCRCs.Vals[folderIndex])
-          res = SZ_ERROR_CRC;
-
-    return res;
-  }
-}

3rdparty/7z/src/7zFile.c

@@ -1,442 +0,0 @@
-/* 7zFile.c -- File IO
-2021-04-29 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "7zFile.h"
-
-#ifndef USE_WINDOWS_FILE
-
-  #include <errno.h>
-
-  #ifndef USE_FOPEN
-    #include <stdio.h>
-    #include <fcntl.h>
-    #ifdef _WIN32
-      #include <io.h>
-      typedef int ssize_t;
-      typedef int off_t;
-    #else
-      #include <unistd.h>
-    #endif
-  #endif
-
-#else
-
-/*
-   ReadFile and WriteFile functions in Windows have BUG:
-   If you Read or Write 64MB or more (probably min_failure_size = 64MB - 32KB + 1)
-   from/to Network file, it returns ERROR_NO_SYSTEM_RESOURCES
-   (Insufficient system resources exist to complete the requested service).
-   Probably in some version of Windows there are problems with other sizes:
-   for 32 MB (maybe also for 16 MB).
-   And message can be "Network connection was lost"
-*/
-
-#endif
-
-#define kChunkSizeMax (1 << 22)
-
-void File_Construct(CSzFile *p)
-{
-  #ifdef USE_WINDOWS_FILE
-  p->handle = INVALID_HANDLE_VALUE;
-  #elif defined(USE_FOPEN)
-  p->file = NULL;
-  #else
-  p->fd = -1;
-  #endif
-}
-
-#if !defined(UNDER_CE) || !defined(USE_WINDOWS_FILE)
-
-static WRes File_Open(CSzFile *p, const char *name, int writeMode)
-{
-  #ifdef USE_WINDOWS_FILE
-  
-  p->handle = CreateFileA(name,
-      writeMode ? GENERIC_WRITE : GENERIC_READ,
-      FILE_SHARE_READ, NULL,
-      writeMode ? CREATE_ALWAYS : OPEN_EXISTING,
-      FILE_ATTRIBUTE_NORMAL, NULL);
-  return (p->handle != INVALID_HANDLE_VALUE) ? 0 : GetLastError();
-  
-  #elif defined(USE_FOPEN)
-  
-  p->file = fopen(name, writeMode ? "wb+" : "rb");
-  return (p->file != 0) ? 0 :
-    #ifdef UNDER_CE
-    2; /* ENOENT */
-    #else
-    errno;
-    #endif
-  
-  #else
-
-  int flags = (writeMode ? (O_CREAT | O_EXCL | O_WRONLY) : O_RDONLY);
-  #ifdef O_BINARY
-  flags |= O_BINARY;
-  #endif
-  p->fd = open(name, flags, 0666);
-  return (p->fd != -1) ? 0 : errno;
-
-  #endif
-}
-
-WRes InFile_Open(CSzFile *p, const char *name) { return File_Open(p, name, 0); }
-
-WRes OutFile_Open(CSzFile *p, const char *name)
-{
-  #if defined(USE_WINDOWS_FILE) || defined(USE_FOPEN)
-  return File_Open(p, name, 1);
-  #else
-  p->fd = creat(name, 0666);
-  return (p->fd != -1) ? 0 : errno;
-  #endif
-}
-
-#endif
-
-
-#ifdef USE_WINDOWS_FILE
-static WRes File_OpenW(CSzFile *p, const WCHAR *name, int writeMode)
-{
-  p->handle = CreateFileW(name,
-      writeMode ? GENERIC_WRITE : GENERIC_READ,
-      FILE_SHARE_READ, NULL,
-      writeMode ? CREATE_ALWAYS : OPEN_EXISTING,
-      FILE_ATTRIBUTE_NORMAL, NULL);
-  return (p->handle != INVALID_HANDLE_VALUE) ? 0 : GetLastError();
-}
-WRes InFile_OpenW(CSzFile *p, const WCHAR *name) { return File_OpenW(p, name, 0); }
-WRes OutFile_OpenW(CSzFile *p, const WCHAR *name) { return File_OpenW(p, name, 1); }
-#endif
-
-WRes File_Close(CSzFile *p)
-{
-  #ifdef USE_WINDOWS_FILE
-  
-  if (p->handle != INVALID_HANDLE_VALUE)
-  {
-    if (!CloseHandle(p->handle))
-      return GetLastError();
-    p->handle = INVALID_HANDLE_VALUE;
-  }
-  
-  #elif defined(USE_FOPEN)
-
-  if (p->file != NULL)
-  {
-    int res = fclose(p->file);
-    if (res != 0)
-    {
-      if (res == EOF)
-        return errno;
-      return res;
-    }
-    p->file = NULL;
-  }
-
-  #else
-
-  if (p->fd != -1)
-  {
-    if (close(p->fd) != 0)
-      return errno;
-    p->fd = -1;
-  }
-
-  #endif
-
-  return 0;
-}
-
-
-WRes File_Read(CSzFile *p, void *data, size_t *size)
-{
-  size_t originalSize = *size;
-  *size = 0;
-  if (originalSize == 0)
-    return 0;
-
-  #ifdef USE_WINDOWS_FILE
-
-  do
-  {
-    const DWORD curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : (DWORD)originalSize;
-    DWORD processed = 0;
-    const BOOL res = ReadFile(p->handle, data, curSize, &processed, NULL);
-    data = (void *)((Byte *)data + processed);
-    originalSize -= processed;
-    *size += processed;
-    if (!res)
-      return GetLastError();
-    // debug : we can break here for partial reading mode
-    if (processed == 0)
-      break;
-  }
-  while (originalSize > 0);
-
-  #elif defined(USE_FOPEN)
-
-  do
-  {
-    const size_t curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : originalSize;
-    const size_t processed = fread(data, 1, curSize, p->file);
-    data = (void *)((Byte *)data + (size_t)processed);
-    originalSize -= processed;
-    *size += processed;
-    if (processed != curSize)
-      return ferror(p->file);
-    // debug : we can break here for partial reading mode
-    if (processed == 0)
-      break;
-  }
-  while (originalSize > 0);
-
-  #else
-
-  do
-  {
-    const size_t curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : originalSize;
-    const ssize_t processed = read(p->fd, data, curSize);
-    if (processed == -1)
-      return errno;
-    if (processed == 0)
-      break;
-    data = (void *)((Byte *)data + (size_t)processed);
-    originalSize -= (size_t)processed;
-    *size += (size_t)processed;
-    // debug : we can break here for partial reading mode
-    // break;
-  }
-  while (originalSize > 0);
-
-  #endif
-
-  return 0;
-}
-
-
-WRes File_Write(CSzFile *p, const void *data, size_t *size)
-{
-  size_t originalSize = *size;
-  *size = 0;
-  if (originalSize == 0)
-    return 0;
-  
-  #ifdef USE_WINDOWS_FILE
-
-  do
-  {
-    const DWORD curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : (DWORD)originalSize;
-    DWORD processed = 0;
-    const BOOL res = WriteFile(p->handle, data, curSize, &processed, NULL);
-    data = (const void *)((const Byte *)data + processed);
-    originalSize -= processed;
-    *size += processed;
-    if (!res)
-      return GetLastError();
-    if (processed == 0)
-      break;
-  }
-  while (originalSize > 0);
-
-  #elif defined(USE_FOPEN)
-
-  do
-  {
-    const size_t curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : originalSize;
-    const size_t processed = fwrite(data, 1, curSize, p->file);
-    data = (void *)((Byte *)data + (size_t)processed);
-    originalSize -= processed;
-    *size += processed;
-    if (processed != curSize)
-      return ferror(p->file);
-    if (processed == 0)
-      break;
-  }
-  while (originalSize > 0);
-
-  #else
-
-  do
-  {
-    const size_t curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : originalSize;
-    const ssize_t processed = write(p->fd, data, curSize);
-    if (processed == -1)
-      return errno;
-    if (processed == 0)
-      break;
-    data = (void *)((Byte *)data + (size_t)processed);
-    originalSize -= (size_t)processed;
-    *size += (size_t)processed;
-  }
-  while (originalSize > 0);
-
-  #endif
-
-  return 0;
-}
-
-
-WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin)
-{
-  #ifdef USE_WINDOWS_FILE
-
-  DWORD moveMethod;
-  UInt32 low = (UInt32)*pos;
-  LONG high = (LONG)((UInt64)*pos >> 16 >> 16); /* for case when UInt64 is 32-bit only */
-  switch (origin)
-  {
-    case SZ_SEEK_SET: moveMethod = FILE_BEGIN; break;
-    case SZ_SEEK_CUR: moveMethod = FILE_CURRENT; break;
-    case SZ_SEEK_END: moveMethod = FILE_END; break;
-    default: return ERROR_INVALID_PARAMETER;
-  }
-  low = SetFilePointer(p->handle, (LONG)low, &high, moveMethod);
-  if (low == (UInt32)0xFFFFFFFF)
-  {
-    WRes res = GetLastError();
-    if (res != NO_ERROR)
-      return res;
-  }
-  *pos = ((Int64)high << 32) | low;
-  return 0;
-
-  #else
-  
-  int moveMethod; // = origin;
-
-  switch (origin)
-  {
-    case SZ_SEEK_SET: moveMethod = SEEK_SET; break;
-    case SZ_SEEK_CUR: moveMethod = SEEK_CUR; break;
-    case SZ_SEEK_END: moveMethod = SEEK_END; break;
-    default: return EINVAL;
-  }
-  
-  #if defined(USE_FOPEN)
-  {
-    int res = fseek(p->file, (long)*pos, moveMethod);
-    if (res == -1)
-      return errno;
-    *pos = ftell(p->file);
-    if (*pos == -1)
-      return errno;
-    return 0;
-  }
-  #else
-  {
-    off_t res = lseek(p->fd, (off_t)*pos, moveMethod);
-    if (res == -1)
-      return errno;
-    *pos = res;
-    return 0;
-  }
-  
-  #endif // USE_FOPEN
-  #endif // USE_WINDOWS_FILE
-}
-
-
-WRes File_GetLength(CSzFile *p, UInt64 *length)
-{
-  #ifdef USE_WINDOWS_FILE
-  
-  DWORD sizeHigh;
-  DWORD sizeLow = GetFileSize(p->handle, &sizeHigh);
-  if (sizeLow == 0xFFFFFFFF)
-  {
-    DWORD res = GetLastError();
-    if (res != NO_ERROR)
-      return res;
-  }
-  *length = (((UInt64)sizeHigh) << 32) + sizeLow;
-  return 0;
-  
-  #elif defined(USE_FOPEN)
-  
-  long pos = ftell(p->file);
-  int res = fseek(p->file, 0, SEEK_END);
-  *length = ftell(p->file);
-  fseek(p->file, pos, SEEK_SET);
-  return res;
-
-  #else
-
-  off_t pos;
-  *length = 0;
-  pos = lseek(p->fd, 0, SEEK_CUR);
-  if (pos != -1)
-  {
-    const off_t len2 = lseek(p->fd, 0, SEEK_END);
-    const off_t res2 = lseek(p->fd, pos, SEEK_SET);
-    if (len2 != -1)
-    {
-      *length = (UInt64)len2;
-      if (res2 != -1)
-        return 0;
-    }
-  }
-  return errno;
-  
-  #endif
-}
-
-
-/* ---------- FileSeqInStream ---------- */
-
-static SRes FileSeqInStream_Read(const ISeqInStream *pp, void *buf, size_t *size)
-{
-  CFileSeqInStream *p = CONTAINER_FROM_VTBL(pp, CFileSeqInStream, vt);
-  WRes wres = File_Read(&p->file, buf, size);
-  p->wres = wres;
-  return (wres == 0) ? SZ_OK : SZ_ERROR_READ;
-}
-
-void FileSeqInStream_CreateVTable(CFileSeqInStream *p)
-{
-  p->vt.Read = FileSeqInStream_Read;
-}
-
-
-/* ---------- FileInStream ---------- */
-
-static SRes FileInStream_Read(const ISeekInStream *pp, void *buf, size_t *size)
-{
-  CFileInStream *p = CONTAINER_FROM_VTBL(pp, CFileInStream, vt);
-  WRes wres = File_Read(&p->file, buf, size);
-  p->wres = wres;
-  return (wres == 0) ? SZ_OK : SZ_ERROR_READ;
-}
-
-static SRes FileInStream_Seek(const ISeekInStream *pp, Int64 *pos, ESzSeek origin)
-{
-  CFileInStream *p = CONTAINER_FROM_VTBL(pp, CFileInStream, vt);
-  WRes wres = File_Seek(&p->file, pos, origin);
-  p->wres = wres;
-  return (wres == 0) ? SZ_OK : SZ_ERROR_READ;
-}
-
-void FileInStream_CreateVTable(CFileInStream *p)
-{
-  p->vt.Read = FileInStream_Read;
-  p->vt.Seek = FileInStream_Seek;
-}
-
-
-/* ---------- FileOutStream ---------- */
-
-static size_t FileOutStream_Write(const ISeqOutStream *pp, const void *data, size_t size)
-{
-  CFileOutStream *p = CONTAINER_FROM_VTBL(pp, CFileOutStream, vt);
-  WRes wres = File_Write(&p->file, data, &size);
-  p->wres = wres;
-  return size;
-}
-
-void FileOutStream_CreateVTable(CFileOutStream *p)
-{
-  p->vt.Write = FileOutStream_Write;
-}

3rdparty/7z/src/7zFile.h

@@ -1,91 +0,0 @@
-/* 7zFile.h -- File IO
-2021-02-15 : Igor Pavlov : Public domain */
-
-#ifndef __7Z_FILE_H
-#define __7Z_FILE_H
-
-#ifdef _WIN32
-#define USE_WINDOWS_FILE
-// #include <windows.h>
-#endif
-
-#ifdef USE_WINDOWS_FILE
-#include <windows.h>
-#else
-// note: USE_FOPEN mode is limited to 32-bit file size
-// #define USE_FOPEN
-// #include <stdio.h>
-#endif
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-/* ---------- File ---------- */
-
-typedef struct
-{
-  #ifdef USE_WINDOWS_FILE
-  HANDLE handle;
-  #elif defined(USE_FOPEN)
-  FILE *file;
-  #else
-  int fd;
-  #endif
-} CSzFile;
-
-void File_Construct(CSzFile *p);
-#if !defined(UNDER_CE) || !defined(USE_WINDOWS_FILE)
-WRes InFile_Open(CSzFile *p, const char *name);
-WRes OutFile_Open(CSzFile *p, const char *name);
-#endif
-#ifdef USE_WINDOWS_FILE
-WRes InFile_OpenW(CSzFile *p, const WCHAR *name);
-WRes OutFile_OpenW(CSzFile *p, const WCHAR *name);
-#endif
-WRes File_Close(CSzFile *p);
-
-/* reads max(*size, remain file's size) bytes */
-WRes File_Read(CSzFile *p, void *data, size_t *size);
-
-/* writes *size bytes */
-WRes File_Write(CSzFile *p, const void *data, size_t *size);
-
-WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin);
-WRes File_GetLength(CSzFile *p, UInt64 *length);
-
-
-/* ---------- FileInStream ---------- */
-
-typedef struct
-{
-  ISeqInStream vt;
-  CSzFile file;
-  WRes wres;
-} CFileSeqInStream;
-
-void FileSeqInStream_CreateVTable(CFileSeqInStream *p);
-
-
-typedef struct
-{
-  ISeekInStream vt;
-  CSzFile file;
-  WRes wres;
-} CFileInStream;
-
-void FileInStream_CreateVTable(CFileInStream *p);
-
-
-typedef struct
-{
-  ISeqOutStream vt;
-  CSzFile file;
-  WRes wres;
-} CFileOutStream;
-
-void FileOutStream_CreateVTable(CFileOutStream *p);
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/7zStream.c

@@ -1,176 +0,0 @@
-/* 7zStream.c -- 7z Stream functions
-2021-02-09 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include <string.h>
-
-#include "7zTypes.h"
-
-SRes SeqInStream_Read2(const ISeqInStream *stream, void *buf, size_t size, SRes errorType)
-{
-  while (size != 0)
-  {
-    size_t processed = size;
-    RINOK(ISeqInStream_Read(stream, buf, &processed));
-    if (processed == 0)
-      return errorType;
-    buf = (void *)((Byte *)buf + processed);
-    size -= processed;
-  }
-  return SZ_OK;
-}
-
-SRes SeqInStream_Read(const ISeqInStream *stream, void *buf, size_t size)
-{
-  return SeqInStream_Read2(stream, buf, size, SZ_ERROR_INPUT_EOF);
-}
-
-SRes SeqInStream_ReadByte(const ISeqInStream *stream, Byte *buf)
-{
-  size_t processed = 1;
-  RINOK(ISeqInStream_Read(stream, buf, &processed));
-  return (processed == 1) ? SZ_OK : SZ_ERROR_INPUT_EOF;
-}
-
-
-
-SRes LookInStream_SeekTo(const ILookInStream *stream, UInt64 offset)
-{
-  Int64 t = (Int64)offset;
-  return ILookInStream_Seek(stream, &t, SZ_SEEK_SET);
-}
-
-SRes LookInStream_LookRead(const ILookInStream *stream, void *buf, size_t *size)
-{
-  const void *lookBuf;
-  if (*size == 0)
-    return SZ_OK;
-  RINOK(ILookInStream_Look(stream, &lookBuf, size));
-  memcpy(buf, lookBuf, *size);
-  return ILookInStream_Skip(stream, *size);
-}
-
-SRes LookInStream_Read2(const ILookInStream *stream, void *buf, size_t size, SRes errorType)
-{
-  while (size != 0)
-  {
-    size_t processed = size;
-    RINOK(ILookInStream_Read(stream, buf, &processed));
-    if (processed == 0)
-      return errorType;
-    buf = (void *)((Byte *)buf + processed);
-    size -= processed;
-  }
-  return SZ_OK;
-}
-
-SRes LookInStream_Read(const ILookInStream *stream, void *buf, size_t size)
-{
-  return LookInStream_Read2(stream, buf, size, SZ_ERROR_INPUT_EOF);
-}
-
-
-
-#define GET_LookToRead2 CLookToRead2 *p = CONTAINER_FROM_VTBL(pp, CLookToRead2, vt);
-
-static SRes LookToRead2_Look_Lookahead(const ILookInStream *pp, const void **buf, size_t *size)
-{
-  SRes res = SZ_OK;
-  GET_LookToRead2
-  size_t size2 = p->size - p->pos;
-  if (size2 == 0 && *size != 0)
-  {
-    p->pos = 0;
-    p->size = 0;
-    size2 = p->bufSize;
-    res = ISeekInStream_Read(p->realStream, p->buf, &size2);
-    p->size = size2;
-  }
-  if (*size > size2)
-    *size = size2;
-  *buf = p->buf + p->pos;
-  return res;
-}
-
-static SRes LookToRead2_Look_Exact(const ILookInStream *pp, const void **buf, size_t *size)
-{
-  SRes res = SZ_OK;
-  GET_LookToRead2
-  size_t size2 = p->size - p->pos;
-  if (size2 == 0 && *size != 0)
-  {
-    p->pos = 0;
-    p->size = 0;
-    if (*size > p->bufSize)
-      *size = p->bufSize;
-    res = ISeekInStream_Read(p->realStream, p->buf, size);
-    size2 = p->size = *size;
-  }
-  if (*size > size2)
-    *size = size2;
-  *buf = p->buf + p->pos;
-  return res;
-}
-
-static SRes LookToRead2_Skip(const ILookInStream *pp, size_t offset)
-{
-  GET_LookToRead2
-  p->pos += offset;
-  return SZ_OK;
-}
-
-static SRes LookToRead2_Read(const ILookInStream *pp, void *buf, size_t *size)
-{
-  GET_LookToRead2
-  size_t rem = p->size - p->pos;
-  if (rem == 0)
-    return ISeekInStream_Read(p->realStream, buf, size);
-  if (rem > *size)
-    rem = *size;
-  memcpy(buf, p->buf + p->pos, rem);
-  p->pos += rem;
-  *size = rem;
-  return SZ_OK;
-}
-
-static SRes LookToRead2_Seek(const ILookInStream *pp, Int64 *pos, ESzSeek origin)
-{
-  GET_LookToRead2
-  p->pos = p->size = 0;
-  return ISeekInStream_Seek(p->realStream, pos, origin);
-}
-
-void LookToRead2_CreateVTable(CLookToRead2 *p, int lookahead)
-{
-  p->vt.Look = lookahead ?
-      LookToRead2_Look_Lookahead :
-      LookToRead2_Look_Exact;
-  p->vt.Skip = LookToRead2_Skip;
-  p->vt.Read = LookToRead2_Read;
-  p->vt.Seek = LookToRead2_Seek;
-}
-
-
-
-static SRes SecToLook_Read(const ISeqInStream *pp, void *buf, size_t *size)
-{
-  CSecToLook *p = CONTAINER_FROM_VTBL(pp, CSecToLook, vt);
-  return LookInStream_LookRead(p->realStream, buf, size);
-}
-
-void SecToLook_CreateVTable(CSecToLook *p)
-{
-  p->vt.Read = SecToLook_Read;
-}
-
-static SRes SecToRead_Read(const ISeqInStream *pp, void *buf, size_t *size)
-{
-  CSecToRead *p = CONTAINER_FROM_VTBL(pp, CSecToRead, vt);
-  return ILookInStream_Read(p->realStream, buf, size);
-}
-
-void SecToRead_CreateVTable(CSecToRead *p)
-{
-  p->vt.Read = SecToRead_Read;
-}

3rdparty/7z/src/7zTypes.h

@@ -1,529 +0,0 @@
-/* 7zTypes.h -- Basic types
-2022-04-01 : Igor Pavlov : Public domain */
-
-#ifndef __7Z_TYPES_H
-#define __7Z_TYPES_H
-
-#ifdef _WIN32
-/* #include <windows.h> */
-#else
-#include <errno.h>
-#endif
-
-#include <stddef.h>
-
-#ifndef EXTERN_C_BEGIN
-#ifdef __cplusplus
-#define EXTERN_C_BEGIN extern "C" {
-#define EXTERN_C_END }
-#else
-#define EXTERN_C_BEGIN
-#define EXTERN_C_END
-#endif
-#endif
-
-EXTERN_C_BEGIN
-
-#define SZ_OK 0
-
-#define SZ_ERROR_DATA 1
-#define SZ_ERROR_MEM 2
-#define SZ_ERROR_CRC 3
-#define SZ_ERROR_UNSUPPORTED 4
-#define SZ_ERROR_PARAM 5
-#define SZ_ERROR_INPUT_EOF 6
-#define SZ_ERROR_OUTPUT_EOF 7
-#define SZ_ERROR_READ 8
-#define SZ_ERROR_WRITE 9
-#define SZ_ERROR_PROGRESS 10
-#define SZ_ERROR_FAIL 11
-#define SZ_ERROR_THREAD 12
-
-#define SZ_ERROR_ARCHIVE 16
-#define SZ_ERROR_NO_ARCHIVE 17
-
-typedef int SRes;
-
-
-#ifdef _MSC_VER
-  #if _MSC_VER > 1200
-    #define MY_ALIGN(n) __declspec(align(n))
-  #else
-    #define MY_ALIGN(n)
-  #endif
-#else
-  #define MY_ALIGN(n) __attribute__ ((aligned(n)))
-#endif
-
-
-#ifdef _WIN32
-
-/* typedef DWORD WRes; */
-typedef unsigned WRes;
-#define MY_SRes_HRESULT_FROM_WRes(x) HRESULT_FROM_WIN32(x)
-
-// #define MY_HRES_ERROR__INTERNAL_ERROR  MY_SRes_HRESULT_FROM_WRes(ERROR_INTERNAL_ERROR)
-
-#else // _WIN32
-
-// #define ENV_HAVE_LSTAT
-typedef int WRes;
-
-// (FACILITY_ERRNO = 0x800) is 7zip's FACILITY constant to represent (errno) errors in HRESULT
-#define MY__FACILITY_ERRNO  0x800
-#define MY__FACILITY_WIN32  7
-#define MY__FACILITY__WRes  MY__FACILITY_ERRNO
-
-#define MY_HRESULT_FROM_errno_CONST_ERROR(x) ((HRESULT)( \
-          ( (HRESULT)(x) & 0x0000FFFF) \
-          | (MY__FACILITY__WRes << 16)  \
-          | (HRESULT)0x80000000 ))
-
-#define MY_SRes_HRESULT_FROM_WRes(x) \
-  ((HRESULT)(x) <= 0 ? ((HRESULT)(x)) : MY_HRESULT_FROM_errno_CONST_ERROR(x))
-
-// we call macro HRESULT_FROM_WIN32 for system errors (WRes) that are (errno)
-#define HRESULT_FROM_WIN32(x) MY_SRes_HRESULT_FROM_WRes(x)
-
-/*
-#define ERROR_FILE_NOT_FOUND             2L
-#define ERROR_ACCESS_DENIED              5L
-#define ERROR_NO_MORE_FILES              18L
-#define ERROR_LOCK_VIOLATION             33L
-#define ERROR_FILE_EXISTS                80L
-#define ERROR_DISK_FULL                  112L
-#define ERROR_NEGATIVE_SEEK              131L
-#define ERROR_ALREADY_EXISTS             183L
-#define ERROR_DIRECTORY                  267L
-#define ERROR_TOO_MANY_POSTS             298L
-
-#define ERROR_INTERNAL_ERROR             1359L
-#define ERROR_INVALID_REPARSE_DATA       4392L
-#define ERROR_REPARSE_TAG_INVALID        4393L
-#define ERROR_REPARSE_TAG_MISMATCH       4394L
-*/
-
-// we use errno equivalents for some WIN32 errors:
-
-#define ERROR_INVALID_PARAMETER     EINVAL
-#define ERROR_INVALID_FUNCTION      EINVAL
-#define ERROR_ALREADY_EXISTS        EEXIST
-#define ERROR_FILE_EXISTS           EEXIST
-#define ERROR_PATH_NOT_FOUND        ENOENT
-#define ERROR_FILE_NOT_FOUND        ENOENT
-#define ERROR_DISK_FULL             ENOSPC
-// #define ERROR_INVALID_HANDLE        EBADF
-
-// we use FACILITY_WIN32 for errors that has no errno equivalent
-// Too many posts were made to a semaphore.
-#define ERROR_TOO_MANY_POSTS        ((HRESULT)0x8007012AL)
-#define ERROR_INVALID_REPARSE_DATA  ((HRESULT)0x80071128L)
-#define ERROR_REPARSE_TAG_INVALID   ((HRESULT)0x80071129L)
-
-// if (MY__FACILITY__WRes != FACILITY_WIN32),
-// we use FACILITY_WIN32 for COM errors:
-#define E_OUTOFMEMORY               ((HRESULT)0x8007000EL)
-#define E_INVALIDARG                ((HRESULT)0x80070057L)
-#define MY__E_ERROR_NEGATIVE_SEEK   ((HRESULT)0x80070083L)
-
-/*
-// we can use FACILITY_ERRNO for some COM errors, that have errno equivalents:
-#define E_OUTOFMEMORY             MY_HRESULT_FROM_errno_CONST_ERROR(ENOMEM)
-#define E_INVALIDARG              MY_HRESULT_FROM_errno_CONST_ERROR(EINVAL)
-#define MY__E_ERROR_NEGATIVE_SEEK MY_HRESULT_FROM_errno_CONST_ERROR(EINVAL)
-*/
-
-#define TEXT(quote) quote
-
-#define FILE_ATTRIBUTE_READONLY       0x0001
-#define FILE_ATTRIBUTE_HIDDEN         0x0002
-#define FILE_ATTRIBUTE_SYSTEM         0x0004
-#define FILE_ATTRIBUTE_DIRECTORY      0x0010
-#define FILE_ATTRIBUTE_ARCHIVE        0x0020
-#define FILE_ATTRIBUTE_DEVICE         0x0040
-#define FILE_ATTRIBUTE_NORMAL         0x0080
-#define FILE_ATTRIBUTE_TEMPORARY      0x0100
-#define FILE_ATTRIBUTE_SPARSE_FILE    0x0200
-#define FILE_ATTRIBUTE_REPARSE_POINT  0x0400
-#define FILE_ATTRIBUTE_COMPRESSED     0x0800
-#define FILE_ATTRIBUTE_OFFLINE        0x1000
-#define FILE_ATTRIBUTE_NOT_CONTENT_INDEXED 0x2000
-#define FILE_ATTRIBUTE_ENCRYPTED      0x4000
-
-#define FILE_ATTRIBUTE_UNIX_EXTENSION 0x8000   /* trick for Unix */
-
-#endif
-
-
-#ifndef RINOK
-#define RINOK(x) { int __result__ = (x); if (__result__ != 0) return __result__; }
-#endif
-
-#ifndef RINOK_WRes
-#define RINOK_WRes(x) { WRes __result__ = (x); if (__result__ != 0) return __result__; }
-#endif
-
-typedef unsigned char Byte;
-typedef short Int16;
-typedef unsigned short UInt16;
-
-#ifdef _LZMA_UINT32_IS_ULONG
-typedef long Int32;
-typedef unsigned long UInt32;
-#else
-typedef int Int32;
-typedef unsigned int UInt32;
-#endif
-
-
-#ifndef _WIN32
-
-typedef int INT;
-typedef Int32 INT32;
-typedef unsigned int UINT;
-typedef UInt32 UINT32;
-typedef INT32 LONG;   // LONG, ULONG and DWORD must be 32-bit for _WIN32 compatibility
-typedef UINT32 ULONG;
-
-#undef DWORD
-typedef UINT32 DWORD;
-
-#define VOID void
-
-#define HRESULT LONG
-
-typedef void *LPVOID;
-// typedef void VOID;
-// typedef ULONG_PTR DWORD_PTR, *PDWORD_PTR;
-// gcc / clang on Unix  : sizeof(long==sizeof(void*) in 32 or 64 bits)
-typedef          long  INT_PTR;
-typedef unsigned long  UINT_PTR;
-typedef          long  LONG_PTR;
-typedef unsigned long  DWORD_PTR;
-
-typedef size_t SIZE_T;
-
-#endif //  _WIN32
-
-
-#define MY_HRES_ERROR__INTERNAL_ERROR  ((HRESULT)0x8007054FL)
-
-
-#ifdef _SZ_NO_INT_64
-
-/* define _SZ_NO_INT_64, if your compiler doesn't support 64-bit integers.
-   NOTES: Some code will work incorrectly in that case! */
-
-typedef long Int64;
-typedef unsigned long UInt64;
-
-#else
-
-#if defined(_MSC_VER) || defined(__BORLANDC__)
-typedef __int64 Int64;
-typedef unsigned __int64 UInt64;
-#define UINT64_CONST(n) n
-#else
-typedef long long int Int64;
-typedef unsigned long long int UInt64;
-#define UINT64_CONST(n) n ## ULL
-#endif
-
-#endif
-
-#ifdef _LZMA_NO_SYSTEM_SIZE_T
-typedef UInt32 SizeT;
-#else
-typedef size_t SizeT;
-#endif
-
-typedef int BoolInt;
-/* typedef BoolInt Bool; */
-#define True 1
-#define False 0
-
-
-#ifdef _WIN32
-#define MY_STD_CALL __stdcall
-#else
-#define MY_STD_CALL
-#endif
-
-#ifdef _MSC_VER
-
-#if _MSC_VER >= 1300
-#define MY_NO_INLINE __declspec(noinline)
-#else
-#define MY_NO_INLINE
-#endif
-
-#define MY_FORCE_INLINE __forceinline
-
-#define MY_CDECL __cdecl
-#define MY_FAST_CALL __fastcall
-
-#else //  _MSC_VER
-
-#if (defined(__GNUC__) && (__GNUC__ >= 4)) \
-    || (defined(__clang__) && (__clang_major__ >= 4)) \
-    || defined(__INTEL_COMPILER) \
-    || defined(__xlC__)
-#define MY_NO_INLINE __attribute__((noinline))
-// #define MY_FORCE_INLINE __attribute__((always_inline)) inline
-#else
-#define MY_NO_INLINE
-#endif
-
-#define MY_FORCE_INLINE
-
-
-#define MY_CDECL
-
-#if  defined(_M_IX86) \
-  || defined(__i386__)
-// #define MY_FAST_CALL __attribute__((fastcall))
-// #define MY_FAST_CALL __attribute__((cdecl))
-#define MY_FAST_CALL
-#elif defined(MY_CPU_AMD64)
-// #define MY_FAST_CALL __attribute__((ms_abi))
-#define MY_FAST_CALL
-#else
-#define MY_FAST_CALL
-#endif
-
-#endif //  _MSC_VER
-
-
-/* The following interfaces use first parameter as pointer to structure */
-
-typedef struct IByteIn IByteIn;
-struct IByteIn
-{
-  Byte (*Read)(const IByteIn *p); /* reads one byte, returns 0 in case of EOF or error */
-};
-#define IByteIn_Read(p) (p)->Read(p)
-
-
-typedef struct IByteOut IByteOut;
-struct IByteOut
-{
-  void (*Write)(const IByteOut *p, Byte b);
-};
-#define IByteOut_Write(p, b) (p)->Write(p, b)
-
-
-typedef struct ISeqInStream ISeqInStream;
-struct ISeqInStream
-{
-  SRes (*Read)(const ISeqInStream *p, void *buf, size_t *size);
-    /* if (input(*size) != 0 && output(*size) == 0) means end_of_stream.
-       (output(*size) < input(*size)) is allowed */
-};
-#define ISeqInStream_Read(p, buf, size) (p)->Read(p, buf, size)
-
-/* it can return SZ_ERROR_INPUT_EOF */
-SRes SeqInStream_Read(const ISeqInStream *stream, void *buf, size_t size);
-SRes SeqInStream_Read2(const ISeqInStream *stream, void *buf, size_t size, SRes errorType);
-SRes SeqInStream_ReadByte(const ISeqInStream *stream, Byte *buf);
-
-
-typedef struct ISeqOutStream ISeqOutStream;
-struct ISeqOutStream
-{
-  size_t (*Write)(const ISeqOutStream *p, const void *buf, size_t size);
-    /* Returns: result - the number of actually written bytes.
-       (result < size) means error */
-};
-#define ISeqOutStream_Write(p, buf, size) (p)->Write(p, buf, size)
-
-typedef enum
-{
-  SZ_SEEK_SET = 0,
-  SZ_SEEK_CUR = 1,
-  SZ_SEEK_END = 2
-} ESzSeek;
-
-
-typedef struct ISeekInStream ISeekInStream;
-struct ISeekInStream
-{
-  SRes (*Read)(const ISeekInStream *p, void *buf, size_t *size);  /* same as ISeqInStream::Read */
-  SRes (*Seek)(const ISeekInStream *p, Int64 *pos, ESzSeek origin);
-};
-#define ISeekInStream_Read(p, buf, size)   (p)->Read(p, buf, size)
-#define ISeekInStream_Seek(p, pos, origin) (p)->Seek(p, pos, origin)
-
-
-typedef struct ILookInStream ILookInStream;
-struct ILookInStream
-{
-  SRes (*Look)(const ILookInStream *p, const void **buf, size_t *size);
-    /* if (input(*size) != 0 && output(*size) == 0) means end_of_stream.
-       (output(*size) > input(*size)) is not allowed
-       (output(*size) < input(*size)) is allowed */
-  SRes (*Skip)(const ILookInStream *p, size_t offset);
-    /* offset must be <= output(*size) of Look */
-
-  SRes (*Read)(const ILookInStream *p, void *buf, size_t *size);
-    /* reads directly (without buffer). It's same as ISeqInStream::Read */
-  SRes (*Seek)(const ILookInStream *p, Int64 *pos, ESzSeek origin);
-};
-
-#define ILookInStream_Look(p, buf, size)   (p)->Look(p, buf, size)
-#define ILookInStream_Skip(p, offset)      (p)->Skip(p, offset)
-#define ILookInStream_Read(p, buf, size)   (p)->Read(p, buf, size)
-#define ILookInStream_Seek(p, pos, origin) (p)->Seek(p, pos, origin)
-
-
-SRes LookInStream_LookRead(const ILookInStream *stream, void *buf, size_t *size);
-SRes LookInStream_SeekTo(const ILookInStream *stream, UInt64 offset);
-
-/* reads via ILookInStream::Read */
-SRes LookInStream_Read2(const ILookInStream *stream, void *buf, size_t size, SRes errorType);
-SRes LookInStream_Read(const ILookInStream *stream, void *buf, size_t size);
-
-
-
-typedef struct
-{
-  ILookInStream vt;
-  const ISeekInStream *realStream;
- 
-  size_t pos;
-  size_t size; /* it's data size */
-  
-  /* the following variables must be set outside */
-  Byte *buf;
-  size_t bufSize;
-} CLookToRead2;
-
-void LookToRead2_CreateVTable(CLookToRead2 *p, int lookahead);
-
-#define LookToRead2_Init(p) { (p)->pos = (p)->size = 0; }
-
-
-typedef struct
-{
-  ISeqInStream vt;
-  const ILookInStream *realStream;
-} CSecToLook;
-
-void SecToLook_CreateVTable(CSecToLook *p);
-
-
-
-typedef struct
-{
-  ISeqInStream vt;
-  const ILookInStream *realStream;
-} CSecToRead;
-
-void SecToRead_CreateVTable(CSecToRead *p);
-
-
-typedef struct ICompressProgress ICompressProgress;
-
-struct ICompressProgress
-{
-  SRes (*Progress)(const ICompressProgress *p, UInt64 inSize, UInt64 outSize);
-    /* Returns: result. (result != SZ_OK) means break.
-       Value (UInt64)(Int64)-1 for size means unknown value. */
-};
-#define ICompressProgress_Progress(p, inSize, outSize) (p)->Progress(p, inSize, outSize)
-
-
-
-typedef struct ISzAlloc ISzAlloc;
-typedef const ISzAlloc * ISzAllocPtr;
-
-struct ISzAlloc
-{
-  void *(*Alloc)(ISzAllocPtr p, size_t size);
-  void (*Free)(ISzAllocPtr p, void *address); /* address can be 0 */
-};
-
-#define ISzAlloc_Alloc(p, size) (p)->Alloc(p, size)
-#define ISzAlloc_Free(p, a) (p)->Free(p, a)
-
-/* deprecated */
-#define IAlloc_Alloc(p, size) ISzAlloc_Alloc(p, size)
-#define IAlloc_Free(p, a) ISzAlloc_Free(p, a)
-
-
-
-
-
-#ifndef MY_offsetof
-  #ifdef offsetof
-    #define MY_offsetof(type, m) offsetof(type, m)
-    /*
-    #define MY_offsetof(type, m) FIELD_OFFSET(type, m)
-    */
-  #else
-    #define MY_offsetof(type, m) ((size_t)&(((type *)0)->m))
-  #endif
-#endif
-
-
-
-#ifndef MY_container_of
-
-/*
-#define MY_container_of(ptr, type, m) container_of(ptr, type, m)
-#define MY_container_of(ptr, type, m) CONTAINING_RECORD(ptr, type, m)
-#define MY_container_of(ptr, type, m) ((type *)((char *)(ptr) - offsetof(type, m)))
-#define MY_container_of(ptr, type, m) (&((type *)0)->m == (ptr), ((type *)(((char *)(ptr)) - MY_offsetof(type, m))))
-*/
-
-/*
-  GCC shows warning: "perhaps the 'offsetof' macro was used incorrectly"
-    GCC 3.4.4 : classes with constructor
-    GCC 4.8.1 : classes with non-public variable members"
-*/
-
-#define MY_container_of(ptr, type, m) ((type *)(void *)((char *)(void *)(1 ? (ptr) : &((type *)0)->m) - MY_offsetof(type, m)))
-
-#endif
-
-#define CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m) ((type *)(void *)(ptr))
-
-/*
-#define CONTAINER_FROM_VTBL(ptr, type, m) CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m)
-*/
-#define CONTAINER_FROM_VTBL(ptr, type, m) MY_container_of(ptr, type, m)
-
-#define CONTAINER_FROM_VTBL_CLS(ptr, type, m) CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m)
-/*
-#define CONTAINER_FROM_VTBL_CLS(ptr, type, m) CONTAINER_FROM_VTBL(ptr, type, m)
-*/
-
-
-#define MY_memset_0_ARRAY(a) memset((a), 0, sizeof(a))
-
-#ifdef _WIN32
-
-#define CHAR_PATH_SEPARATOR '\\'
-#define WCHAR_PATH_SEPARATOR L'\\'
-#define STRING_PATH_SEPARATOR "\\"
-#define WSTRING_PATH_SEPARATOR L"\\"
-
-#else
-
-#define CHAR_PATH_SEPARATOR '/'
-#define WCHAR_PATH_SEPARATOR L'/'
-#define STRING_PATH_SEPARATOR "/"
-#define WSTRING_PATH_SEPARATOR L"/"
-
-#endif
-
-#define k_PropVar_TimePrec_0        0
-#define k_PropVar_TimePrec_Unix     1
-#define k_PropVar_TimePrec_DOS      2
-#define k_PropVar_TimePrec_HighPrec 3
-#define k_PropVar_TimePrec_Base     16
-#define k_PropVar_TimePrec_100ns (k_PropVar_TimePrec_Base + 7)
-#define k_PropVar_TimePrec_1ns   (k_PropVar_TimePrec_Base + 9)
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/7zVersion.h

@@ -1,27 +0,0 @@
-#define MY_VER_MAJOR 22
-#define MY_VER_MINOR 01
-#define MY_VER_BUILD 0
-#define MY_VERSION_NUMBERS "22.01"
-#define MY_VERSION MY_VERSION_NUMBERS
-
-#ifdef MY_CPU_NAME
-  #define MY_VERSION_CPU MY_VERSION " (" MY_CPU_NAME ")"
-#else
-  #define MY_VERSION_CPU MY_VERSION
-#endif
-
-#define MY_DATE "2022-07-15"
-#undef MY_COPYRIGHT
-#undef MY_VERSION_COPYRIGHT_DATE
-#define MY_AUTHOR_NAME "Igor Pavlov"
-#define MY_COPYRIGHT_PD "Igor Pavlov : Public domain"
-#define MY_COPYRIGHT_CR "Copyright (c) 1999-2022 Igor Pavlov"
-
-#ifdef USE_COPYRIGHT_CR
-  #define MY_COPYRIGHT MY_COPYRIGHT_CR
-#else
-  #define MY_COPYRIGHT MY_COPYRIGHT_PD
-#endif
-
-#define MY_COPYRIGHT_DATE MY_COPYRIGHT " : " MY_DATE
-#define MY_VERSION_COPYRIGHT_DATE MY_VERSION_CPU " : " MY_COPYRIGHT " : " MY_DATE

3rdparty/7z/src/7zVersion.rc

@@ -1,55 +0,0 @@
-#define MY_VS_FFI_FILEFLAGSMASK  0x0000003FL
-#define MY_VOS_NT_WINDOWS32  0x00040004L
-#define MY_VOS_CE_WINDOWS32  0x00050004L
-
-#define MY_VFT_APP  0x00000001L
-#define MY_VFT_DLL  0x00000002L
-
-// #include <WinVer.h>
-
-#ifndef MY_VERSION
-#include "7zVersion.h"
-#endif
-
-#define MY_VER MY_VER_MAJOR,MY_VER_MINOR,MY_VER_BUILD,0
-
-#ifdef DEBUG
-#define DBG_FL VS_FF_DEBUG
-#else
-#define DBG_FL 0
-#endif
-
-#define MY_VERSION_INFO(fileType, descr, intName, origName)  \
-LANGUAGE 9, 1 \
-1 VERSIONINFO \
-  FILEVERSION MY_VER \
-  PRODUCTVERSION MY_VER \
-  FILEFLAGSMASK MY_VS_FFI_FILEFLAGSMASK \
-  FILEFLAGS DBG_FL \
-  FILEOS MY_VOS_NT_WINDOWS32 \
-  FILETYPE fileType \
-  FILESUBTYPE 0x0L \
-BEGIN \
-    BLOCK "StringFileInfo" \
-    BEGIN  \
-        BLOCK "040904b0" \
-        BEGIN \
-            VALUE "CompanyName", "Igor Pavlov" \
-            VALUE "FileDescription", descr \
-            VALUE "FileVersion", MY_VERSION  \
-            VALUE "InternalName", intName \
-            VALUE "LegalCopyright", MY_COPYRIGHT \
-            VALUE "OriginalFilename", origName \
-            VALUE "ProductName", "7-Zip" \
-            VALUE "ProductVersion", MY_VERSION \
-        END \
-    END \
-    BLOCK "VarFileInfo" \
-    BEGIN \
-        VALUE "Translation", 0x409, 1200 \
-    END \
-END
-
-#define MY_VERSION_INFO_APP(descr, intName) MY_VERSION_INFO(MY_VFT_APP, descr, intName, intName ".exe")
-
-#define MY_VERSION_INFO_DLL(descr, intName) MY_VERSION_INFO(MY_VFT_DLL, descr, intName, intName ".dll")

3rdparty/7z/src/Aes.c

@@ -1,375 +0,0 @@
-/* Aes.c -- AES encryption / decryption
-2021-05-13 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "CpuArch.h"
-#include "Aes.h"
-
-AES_CODE_FUNC g_AesCbc_Decode;
-#ifndef _SFX
-AES_CODE_FUNC g_AesCbc_Encode;
-AES_CODE_FUNC g_AesCtr_Code;
-UInt32 g_Aes_SupportedFunctions_Flags;
-#endif
-
-static UInt32 T[256 * 4];
-static const Byte Sbox[256] = {
-  0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
-  0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
-  0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
-  0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
-  0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
-  0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
-  0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
-  0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
-  0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
-  0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
-  0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
-  0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
-  0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
-  0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
-  0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
-  0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16};
-
-
-static UInt32 D[256 * 4];
-static Byte InvS[256];
-
-#define xtime(x) ((((x) << 1) ^ (((x) & 0x80) != 0 ? 0x1B : 0)) & 0xFF)
-
-#define Ui32(a0, a1, a2, a3) ((UInt32)(a0) | ((UInt32)(a1) << 8) | ((UInt32)(a2) << 16) | ((UInt32)(a3) << 24))
-
-#define gb0(x) ( (x)          & 0xFF)
-#define gb1(x) (((x) >> ( 8)) & 0xFF)
-#define gb2(x) (((x) >> (16)) & 0xFF)
-#define gb3(x) (((x) >> (24)))
-
-#define gb(n, x) gb ## n(x)
-
-#define TT(x) (T + (x << 8))
-#define DD(x) (D + (x << 8))
-
-
-// #define _SHOW_AES_STATUS
-
-#ifdef MY_CPU_X86_OR_AMD64
-  #define USE_HW_AES
-#elif defined(MY_CPU_ARM_OR_ARM64) && defined(MY_CPU_LE)
-  #if defined(__clang__)
-    #if (__clang_major__ >= 8) // fix that check
-      #define USE_HW_AES
-    #endif
-  #elif defined(__GNUC__)
-    #if (__GNUC__ >= 6) // fix that check
-      #define USE_HW_AES
-    #endif
-  #elif defined(_MSC_VER)
-    #if _MSC_VER >= 1910
-      #define USE_HW_AES
-    #endif
-  #endif
-#endif
-
-#ifdef USE_HW_AES
-#ifdef _SHOW_AES_STATUS
-#include <stdio.h>
-#define _PRF(x) x
-#else
-#define _PRF(x)
-#endif
-#endif
-
-
-void AesGenTables(void)
-{
-  unsigned i;
-  for (i = 0; i < 256; i++)
-    InvS[Sbox[i]] = (Byte)i;
-  
-  for (i = 0; i < 256; i++)
-  {
-    {
-      UInt32 a1 = Sbox[i];
-      UInt32 a2 = xtime(a1);
-      UInt32 a3 = a2 ^ a1;
-      TT(0)[i] = Ui32(a2, a1, a1, a3);
-      TT(1)[i] = Ui32(a3, a2, a1, a1);
-      TT(2)[i] = Ui32(a1, a3, a2, a1);
-      TT(3)[i] = Ui32(a1, a1, a3, a2);
-    }
-    {
-      UInt32 a1 = InvS[i];
-      UInt32 a2 = xtime(a1);
-      UInt32 a4 = xtime(a2);
-      UInt32 a8 = xtime(a4);
-      UInt32 a9 = a8 ^ a1;
-      UInt32 aB = a8 ^ a2 ^ a1;
-      UInt32 aD = a8 ^ a4 ^ a1;
-      UInt32 aE = a8 ^ a4 ^ a2;
-      DD(0)[i] = Ui32(aE, a9, aD, aB);
-      DD(1)[i] = Ui32(aB, aE, a9, aD);
-      DD(2)[i] = Ui32(aD, aB, aE, a9);
-      DD(3)[i] = Ui32(a9, aD, aB, aE);
-    }
-  }
-  
-  {
-  AES_CODE_FUNC d = AesCbc_Decode;
-  #ifndef _SFX
-  AES_CODE_FUNC e = AesCbc_Encode;
-  AES_CODE_FUNC c = AesCtr_Code;
-  UInt32 flags = 0;
-  #endif
-  
-  #ifdef USE_HW_AES
-  if (CPU_IsSupported_AES())
-  {
-    // #pragma message ("AES HW")
-    _PRF(printf("\n===AES HW\n"));
-    d = AesCbc_Decode_HW;
-
-    #ifndef _SFX
-    e = AesCbc_Encode_HW;
-    c = AesCtr_Code_HW;
-    flags = k_Aes_SupportedFunctions_HW;
-    #endif
-
-    #ifdef MY_CPU_X86_OR_AMD64
-    if (CPU_IsSupported_VAES_AVX2())
-    {
-      _PRF(printf("\n===vaes avx2\n"));
-      d = AesCbc_Decode_HW_256;
-      #ifndef _SFX
-      c = AesCtr_Code_HW_256;
-      flags |= k_Aes_SupportedFunctions_HW_256;
-      #endif
-    }
-    #endif
-  }
-  #endif
-
-  g_AesCbc_Decode = d;
-  #ifndef _SFX
-  g_AesCbc_Encode = e;
-  g_AesCtr_Code = c;
-  g_Aes_SupportedFunctions_Flags = flags;
-  #endif
-  }
-}
-
-
-#define HT(i, x, s) TT(x)[gb(x, s[(i + x) & 3])]
-
-#define HT4(m, i, s, p) m[i] = \
-    HT(i, 0, s) ^ \
-    HT(i, 1, s) ^ \
-    HT(i, 2, s) ^ \
-    HT(i, 3, s) ^ w[p + i]
-
-#define HT16(m, s, p) \
-    HT4(m, 0, s, p); \
-    HT4(m, 1, s, p); \
-    HT4(m, 2, s, p); \
-    HT4(m, 3, s, p); \
-
-#define FT(i, x) Sbox[gb(x, m[(i + x) & 3])]
-#define FT4(i) dest[i] = Ui32(FT(i, 0), FT(i, 1), FT(i, 2), FT(i, 3)) ^ w[i];
-
-
-#define HD(i, x, s) DD(x)[gb(x, s[(i - x) & 3])]
-
-#define HD4(m, i, s, p) m[i] = \
-    HD(i, 0, s) ^ \
-    HD(i, 1, s) ^ \
-    HD(i, 2, s) ^ \
-    HD(i, 3, s) ^ w[p + i];
-
-#define HD16(m, s, p) \
-    HD4(m, 0, s, p); \
-    HD4(m, 1, s, p); \
-    HD4(m, 2, s, p); \
-    HD4(m, 3, s, p); \
-
-#define FD(i, x) InvS[gb(x, m[(i - x) & 3])]
-#define FD4(i) dest[i] = Ui32(FD(i, 0), FD(i, 1), FD(i, 2), FD(i, 3)) ^ w[i];
-
-void MY_FAST_CALL Aes_SetKey_Enc(UInt32 *w, const Byte *key, unsigned keySize)
-{
-  unsigned i, m;
-  const UInt32 *wLim;
-  UInt32 t;
-  UInt32 rcon = 1;
-  
-  keySize /= 4;
-  w[0] = ((UInt32)keySize / 2) + 3;
-  w += 4;
-
-  for (i = 0; i < keySize; i++, key += 4)
-    w[i] = GetUi32(key);
-
-  t = w[(size_t)keySize - 1];
-  wLim = w + (size_t)keySize * 3 + 28;
-  m = 0;
-  do
-  {
-    if (m == 0)
-    {
-      t = Ui32(Sbox[gb1(t)] ^ rcon, Sbox[gb2(t)], Sbox[gb3(t)], Sbox[gb0(t)]);
-      rcon <<= 1;
-      if (rcon & 0x100)
-        rcon = 0x1b;
-      m = keySize;
-    }
-    else if (m == 4 && keySize > 6)
-      t = Ui32(Sbox[gb0(t)], Sbox[gb1(t)], Sbox[gb2(t)], Sbox[gb3(t)]);
-    m--;
-    t ^= w[0];
-    w[keySize] = t;
-  }
-  while (++w != wLim);
-}
-
-void MY_FAST_CALL Aes_SetKey_Dec(UInt32 *w, const Byte *key, unsigned keySize)
-{
-  unsigned i, num;
-  Aes_SetKey_Enc(w, key, keySize);
-  num = keySize + 20;
-  w += 8;
-  for (i = 0; i < num; i++)
-  {
-    UInt32 r = w[i];
-    w[i] =
-      DD(0)[Sbox[gb0(r)]] ^
-      DD(1)[Sbox[gb1(r)]] ^
-      DD(2)[Sbox[gb2(r)]] ^
-      DD(3)[Sbox[gb3(r)]];
-  }
-}
-
-/* Aes_Encode and Aes_Decode functions work with little-endian words.
-  src and dest are pointers to 4 UInt32 words.
-  src and dest can point to same block */
-
-// MY_FORCE_INLINE
-static void Aes_Encode(const UInt32 *w, UInt32 *dest, const UInt32 *src)
-{
-  UInt32 s[4];
-  UInt32 m[4];
-  UInt32 numRounds2 = w[0];
-  w += 4;
-  s[0] = src[0] ^ w[0];
-  s[1] = src[1] ^ w[1];
-  s[2] = src[2] ^ w[2];
-  s[3] = src[3] ^ w[3];
-  w += 4;
-  for (;;)
-  {
-    HT16(m, s, 0);
-    if (--numRounds2 == 0)
-      break;
-    HT16(s, m, 4);
-    w += 8;
-  }
-  w += 4;
-  FT4(0); FT4(1); FT4(2); FT4(3);
-}
-
-MY_FORCE_INLINE
-static void Aes_Decode(const UInt32 *w, UInt32 *dest, const UInt32 *src)
-{
-  UInt32 s[4];
-  UInt32 m[4];
-  UInt32 numRounds2 = w[0];
-  w += 4 + numRounds2 * 8;
-  s[0] = src[0] ^ w[0];
-  s[1] = src[1] ^ w[1];
-  s[2] = src[2] ^ w[2];
-  s[3] = src[3] ^ w[3];
-  for (;;)
-  {
-    w -= 8;
-    HD16(m, s, 4);
-    if (--numRounds2 == 0)
-      break;
-    HD16(s, m, 0);
-  }
-  FD4(0); FD4(1); FD4(2); FD4(3);
-}
-
-void AesCbc_Init(UInt32 *p, const Byte *iv)
-{
-  unsigned i;
-  for (i = 0; i < 4; i++)
-    p[i] = GetUi32(iv + i * 4);
-}
-
-void MY_FAST_CALL AesCbc_Encode(UInt32 *p, Byte *data, size_t numBlocks)
-{
-  for (; numBlocks != 0; numBlocks--, data += AES_BLOCK_SIZE)
-  {
-    p[0] ^= GetUi32(data);
-    p[1] ^= GetUi32(data + 4);
-    p[2] ^= GetUi32(data + 8);
-    p[3] ^= GetUi32(data + 12);
-    
-    Aes_Encode(p + 4, p, p);
-    
-    SetUi32(data,      p[0]);
-    SetUi32(data + 4,  p[1]);
-    SetUi32(data + 8,  p[2]);
-    SetUi32(data + 12, p[3]);
-  }
-}
-
-void MY_FAST_CALL AesCbc_Decode(UInt32 *p, Byte *data, size_t numBlocks)
-{
-  UInt32 in[4], out[4];
-  for (; numBlocks != 0; numBlocks--, data += AES_BLOCK_SIZE)
-  {
-    in[0] = GetUi32(data);
-    in[1] = GetUi32(data + 4);
-    in[2] = GetUi32(data + 8);
-    in[3] = GetUi32(data + 12);
-
-    Aes_Decode(p + 4, out, in);
-
-    SetUi32(data,      p[0] ^ out[0]);
-    SetUi32(data + 4,  p[1] ^ out[1]);
-    SetUi32(data + 8,  p[2] ^ out[2]);
-    SetUi32(data + 12, p[3] ^ out[3]);
-    
-    p[0] = in[0];
-    p[1] = in[1];
-    p[2] = in[2];
-    p[3] = in[3];
-  }
-}
-
-void MY_FAST_CALL AesCtr_Code(UInt32 *p, Byte *data, size_t numBlocks)
-{
-  for (; numBlocks != 0; numBlocks--)
-  {
-    UInt32 temp[4];
-    unsigned i;
-
-    if (++p[0] == 0)
-      p[1]++;
-    
-    Aes_Encode(p + 4, temp, p);
-    
-    for (i = 0; i < 4; i++, data += 4)
-    {
-      UInt32 t = temp[i];
-
-      #ifdef MY_CPU_LE_UNALIGN
-        *((UInt32 *)(void *)data) ^= t;
-      #else
-        data[0] = (Byte)(data[0] ^ (t & 0xFF));
-        data[1] = (Byte)(data[1] ^ ((t >> 8) & 0xFF));
-        data[2] = (Byte)(data[2] ^ ((t >> 16) & 0xFF));
-        data[3] = (Byte)(data[3] ^ ((t >> 24)));
-      #endif
-    }
-  }
-}

3rdparty/7z/src/Aes.h

@@ -1,60 +0,0 @@
-/* Aes.h -- AES encryption / decryption
-2018-04-28 : Igor Pavlov : Public domain */
-
-#ifndef __AES_H
-#define __AES_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-#define AES_BLOCK_SIZE 16
-
-/* Call AesGenTables one time before other AES functions */
-void AesGenTables(void);
-
-/* UInt32 pointers must be 16-byte aligned */
-
-/* 16-byte (4 * 32-bit words) blocks: 1 (IV) + 1 (keyMode) + 15 (AES-256 roundKeys) */
-#define AES_NUM_IVMRK_WORDS ((1 + 1 + 15) * 4)
-
-/* aes - 16-byte aligned pointer to keyMode+roundKeys sequence */
-/* keySize = 16 or 24 or 32 (bytes) */
-typedef void (MY_FAST_CALL *AES_SET_KEY_FUNC)(UInt32 *aes, const Byte *key, unsigned keySize);
-void MY_FAST_CALL Aes_SetKey_Enc(UInt32 *aes, const Byte *key, unsigned keySize);
-void MY_FAST_CALL Aes_SetKey_Dec(UInt32 *aes, const Byte *key, unsigned keySize);
-
-/* ivAes - 16-byte aligned pointer to iv+keyMode+roundKeys sequence: UInt32[AES_NUM_IVMRK_WORDS] */
-void AesCbc_Init(UInt32 *ivAes, const Byte *iv); /* iv size is AES_BLOCK_SIZE */
-
-/* data - 16-byte aligned pointer to data */
-/* numBlocks - the number of 16-byte blocks in data array */
-typedef void (MY_FAST_CALL *AES_CODE_FUNC)(UInt32 *ivAes, Byte *data, size_t numBlocks);
-
-extern AES_CODE_FUNC g_AesCbc_Decode;
-#ifndef _SFX
-extern AES_CODE_FUNC g_AesCbc_Encode;
-extern AES_CODE_FUNC g_AesCtr_Code;
-#define k_Aes_SupportedFunctions_HW     (1 << 2)
-#define k_Aes_SupportedFunctions_HW_256 (1 << 3)
-extern UInt32 g_Aes_SupportedFunctions_Flags;
-#endif
-
-
-#define DECLARE__AES_CODE_FUNC(funcName) \
-    void MY_FAST_CALL funcName(UInt32 *ivAes, Byte *data, size_t numBlocks);
-
-DECLARE__AES_CODE_FUNC (AesCbc_Encode)
-DECLARE__AES_CODE_FUNC (AesCbc_Decode)
-DECLARE__AES_CODE_FUNC (AesCtr_Code)
-
-DECLARE__AES_CODE_FUNC (AesCbc_Encode_HW)
-DECLARE__AES_CODE_FUNC (AesCbc_Decode_HW)
-DECLARE__AES_CODE_FUNC (AesCtr_Code_HW)
-
-DECLARE__AES_CODE_FUNC (AesCbc_Decode_HW_256)
-DECLARE__AES_CODE_FUNC (AesCtr_Code_HW_256)
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/AesOpt.c

@@ -1,776 +0,0 @@
-/* AesOpt.c -- AES optimized code for x86 AES hardware instructions
-2021-04-01 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "CpuArch.h"
-
-#ifdef MY_CPU_X86_OR_AMD64
-
-  #if defined(__clang__)
-    #if __clang_major__ > 3 || (__clang_major__ == 3 && __clang_minor__ >= 8)
-      #define USE_INTEL_AES
-        #define ATTRIB_AES __attribute__((__target__("aes")))
-      #if (__clang_major__ >= 8)
-        #define USE_INTEL_VAES
-        #define ATTRIB_VAES __attribute__((__target__("aes,vaes,avx2")))
-      #endif
-    #endif
-  #elif defined(__GNUC__)
-    #if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)
-      #define USE_INTEL_AES
-      #ifndef __AES__
-        #define ATTRIB_AES __attribute__((__target__("aes")))
-      #endif
-      #if (__GNUC__ >= 8)
-        #define USE_INTEL_VAES
-        #define ATTRIB_VAES __attribute__((__target__("aes,vaes,avx2")))
-      #endif
-    #endif
-  #elif defined(__INTEL_COMPILER)
-    #if (__INTEL_COMPILER >= 1110)
-      #define USE_INTEL_AES
-      #if (__INTEL_COMPILER >= 1900)
-        #define USE_INTEL_VAES
-      #endif
-    #endif
-  #elif defined(_MSC_VER)
-    #if (_MSC_VER > 1500) || (_MSC_FULL_VER >= 150030729)
-      #define USE_INTEL_AES
-      #if (_MSC_VER >= 1910)
-        #define USE_INTEL_VAES
-      #endif
-    #endif
-  #endif
-
-#ifndef ATTRIB_AES
-  #define ATTRIB_AES
-#endif
-#ifndef ATTRIB_VAES
-  #define ATTRIB_VAES
-#endif
-
-
-#ifdef USE_INTEL_AES
-
-#include <wmmintrin.h>
-
-#ifndef USE_INTEL_VAES
-#define AES_TYPE_keys __m128i
-#define AES_TYPE_data __m128i
-#endif
-
-#define AES_FUNC_START(name) \
-    void MY_FAST_CALL name(__m128i *p, __m128i *data, size_t numBlocks)
-
-#define AES_FUNC_START2(name) \
-AES_FUNC_START (name); \
-ATTRIB_AES \
-AES_FUNC_START (name)
-
-#define MM_OP(op, dest, src)  dest = op(dest, src);
-#define MM_OP_m(op, src)      MM_OP(op, m, src);
-
-#define MM_XOR( dest, src)    MM_OP(_mm_xor_si128,    dest, src);
-#define AVX_XOR(dest, src)    MM_OP(_mm256_xor_si256, dest, src);
-
-
-AES_FUNC_START2 (AesCbc_Encode_HW)
-{
-  __m128i m = *p;
-  const __m128i k0 = p[2];
-  const __m128i k1 = p[3];
-  const UInt32 numRounds2 = *(const UInt32 *)(p + 1) - 1;
-  for (; numBlocks != 0; numBlocks--, data++)
-  {
-    UInt32 r = numRounds2;
-    const __m128i *w = p + 4;
-    __m128i temp = *data;
-    MM_XOR (temp, k0);
-    MM_XOR (m, temp);
-    MM_OP_m (_mm_aesenc_si128, k1);
-    do
-    {
-      MM_OP_m (_mm_aesenc_si128, w[0]);
-      MM_OP_m (_mm_aesenc_si128, w[1]);
-      w += 2;
-    }
-    while (--r);
-    MM_OP_m (_mm_aesenclast_si128, w[0]);
-    *data = m;
-  }
-  *p = m;
-}
-
-
-#define WOP_1(op)
-#define WOP_2(op)   WOP_1 (op)  op (m1, 1);
-#define WOP_3(op)   WOP_2 (op)  op (m2, 2);
-#define WOP_4(op)   WOP_3 (op)  op (m3, 3);
-#ifdef MY_CPU_AMD64
-#define WOP_5(op)   WOP_4 (op)  op (m4, 4);
-#define WOP_6(op)   WOP_5 (op)  op (m5, 5);
-#define WOP_7(op)   WOP_6 (op)  op (m6, 6);
-#define WOP_8(op)   WOP_7 (op)  op (m7, 7);
-#endif
-/*
-#define WOP_9(op)   WOP_8 (op)  op (m8, 8);
-#define WOP_10(op)  WOP_9 (op)  op (m9, 9);
-#define WOP_11(op)  WOP_10(op)  op (m10, 10);
-#define WOP_12(op)  WOP_11(op)  op (m11, 11);
-#define WOP_13(op)  WOP_12(op)  op (m12, 12);
-#define WOP_14(op)  WOP_13(op)  op (m13, 13);
-*/
-
-#ifdef MY_CPU_AMD64
-  #define NUM_WAYS      8
-  #define WOP_M1    WOP_8
-#else
-  #define NUM_WAYS      4
-  #define WOP_M1    WOP_4
-#endif
-
-#define WOP(op)  op (m0, 0);  WOP_M1(op)
-
-
-#define DECLARE_VAR(reg, ii)  __m128i reg
-#define LOAD_data(  reg, ii)  reg = data[ii];
-#define STORE_data( reg, ii)  data[ii] = reg;
-#if (NUM_WAYS > 1)
-#define XOR_data_M1(reg, ii)  MM_XOR (reg, data[ii- 1]);
-#endif
-
-#define AVX__DECLARE_VAR(reg, ii)  __m256i reg
-#define AVX__LOAD_data(  reg, ii)  reg = ((const __m256i *)(const void *)data)[ii];
-#define AVX__STORE_data( reg, ii)  ((__m256i *)(void *)data)[ii] = reg;
-#define AVX__XOR_data_M1(reg, ii)  AVX_XOR (reg, (((const __m256i *)(const void *)(data - 1))[ii]));
-
-#define MM_OP_key(op, reg)  MM_OP(op, reg, key);
-
-#define AES_DEC(      reg, ii)   MM_OP_key (_mm_aesdec_si128,     reg)
-#define AES_DEC_LAST( reg, ii)   MM_OP_key (_mm_aesdeclast_si128, reg)
-#define AES_ENC(      reg, ii)   MM_OP_key (_mm_aesenc_si128,     reg)
-#define AES_ENC_LAST( reg, ii)   MM_OP_key (_mm_aesenclast_si128, reg)
-#define AES_XOR(      reg, ii)   MM_OP_key (_mm_xor_si128,        reg)
-
-
-#define AVX__AES_DEC(      reg, ii)   MM_OP_key (_mm256_aesdec_epi128,     reg)
-#define AVX__AES_DEC_LAST( reg, ii)   MM_OP_key (_mm256_aesdeclast_epi128, reg)
-#define AVX__AES_ENC(      reg, ii)   MM_OP_key (_mm256_aesenc_epi128,     reg)
-#define AVX__AES_ENC_LAST( reg, ii)   MM_OP_key (_mm256_aesenclast_epi128, reg)
-#define AVX__AES_XOR(      reg, ii)   MM_OP_key (_mm256_xor_si256,         reg)
-
-#define CTR_START(reg, ii)  MM_OP (_mm_add_epi64, ctr, one); reg = ctr;
-#define CTR_END(  reg, ii)  MM_XOR (data[ii], reg);
-
-#define AVX__CTR_START(reg, ii)  MM_OP (_mm256_add_epi64, ctr2, two); reg = _mm256_xor_si256(ctr2, key);
-#define AVX__CTR_END(  reg, ii)  AVX_XOR (((__m256i *)(void *)data)[ii], reg);
-
-#define WOP_KEY(op, n) { \
-    const __m128i key = w[n]; \
-    WOP(op); }
-
-#define AVX__WOP_KEY(op, n) { \
-    const __m256i key = w[n]; \
-    WOP(op); }
-
-
-#define WIDE_LOOP_START  \
-    dataEnd = data + numBlocks;  \
-    if (numBlocks >= NUM_WAYS)  \
-    { dataEnd -= NUM_WAYS; do {  \
-
-
-#define WIDE_LOOP_END  \
-    data += NUM_WAYS;  \
-    } while (data <= dataEnd);  \
-    dataEnd += NUM_WAYS; }  \
-
-
-#define SINGLE_LOOP  \
-    for (; data < dataEnd; data++)
-
-
-#define NUM_AES_KEYS_MAX 15
-
-#define WIDE_LOOP_START_AVX(OP)  \
-    dataEnd = data + numBlocks;  \
-    if (numBlocks >= NUM_WAYS * 2)  \
-    { __m256i keys[NUM_AES_KEYS_MAX]; \
-    UInt32 ii; \
-    OP \
-    for (ii = 0; ii < numRounds; ii++) \
-      keys[ii] = _mm256_broadcastsi128_si256(p[ii]); \
-    dataEnd -= NUM_WAYS * 2; do {  \
-
-
-#define WIDE_LOOP_END_AVX(OP)  \
-    data += NUM_WAYS * 2;  \
-    } while (data <= dataEnd);  \
-    dataEnd += NUM_WAYS * 2;  \
-    OP  \
-    _mm256_zeroupper();  \
-    }  \
-
-/* MSVC for x86: If we don't call _mm256_zeroupper(), and -arch:IA32 is not specified,
-   MSVC still can insert vzeroupper instruction. */
-
-
-AES_FUNC_START2 (AesCbc_Decode_HW)
-{
-  __m128i iv = *p;
-  const __m128i *wStart = p + *(const UInt32 *)(p + 1) * 2 + 2 - 1;
-  const __m128i *dataEnd;
-  p += 2;
-  
-  WIDE_LOOP_START
-  {
-    const __m128i *w = wStart;
-    
-    WOP (DECLARE_VAR)
-    WOP (LOAD_data);
-    WOP_KEY (AES_XOR, 1)
-
-    do
-    {
-      WOP_KEY (AES_DEC, 0)
-      w--;
-    }
-    while (w != p);
-    WOP_KEY (AES_DEC_LAST, 0)
-
-    MM_XOR (m0, iv);
-    WOP_M1 (XOR_data_M1)
-    iv = data[NUM_WAYS - 1];
-    WOP (STORE_data);
-  }
-  WIDE_LOOP_END
-
-  SINGLE_LOOP
-  {
-    const __m128i *w = wStart - 1;
-    __m128i m = _mm_xor_si128 (w[2], *data);
-    do
-    {
-      MM_OP_m (_mm_aesdec_si128, w[1]);
-      MM_OP_m (_mm_aesdec_si128, w[0]);
-      w -= 2;
-    }
-    while (w != p);
-    MM_OP_m (_mm_aesdec_si128,     w[1]);
-    MM_OP_m (_mm_aesdeclast_si128, w[0]);
-
-    MM_XOR (m, iv);
-    iv = *data;
-    *data = m;
-  }
-  
-  p[-2] = iv;
-}
-
-
-AES_FUNC_START2 (AesCtr_Code_HW)
-{
-  __m128i ctr = *p;
-  UInt32 numRoundsMinus2 = *(const UInt32 *)(p + 1) * 2 - 1;
-  const __m128i *dataEnd;
-  __m128i one = _mm_cvtsi32_si128(1);
-
-  p += 2;
-  
-  WIDE_LOOP_START
-  {
-    const __m128i *w = p;
-    UInt32 r = numRoundsMinus2;
-    WOP (DECLARE_VAR)
-    WOP (CTR_START);
-    WOP_KEY (AES_XOR, 0)
-    w += 1;
-    do
-    {
-      WOP_KEY (AES_ENC, 0)
-      w += 1;
-    }
-    while (--r);
-    WOP_KEY (AES_ENC_LAST, 0)
-   
-    WOP (CTR_END);
-  }
-  WIDE_LOOP_END
-
-  SINGLE_LOOP
-  {
-    UInt32 numRounds2 = *(const UInt32 *)(p - 2 + 1) - 1;
-    const __m128i *w = p;
-    __m128i m;
-    MM_OP (_mm_add_epi64, ctr, one);
-    m = _mm_xor_si128 (ctr, p[0]);
-    w += 1;
-    do
-    {
-      MM_OP_m (_mm_aesenc_si128, w[0]);
-      MM_OP_m (_mm_aesenc_si128, w[1]);
-      w += 2;
-    }
-    while (--numRounds2);
-    MM_OP_m (_mm_aesenc_si128,     w[0]);
-    MM_OP_m (_mm_aesenclast_si128, w[1]);
-    MM_XOR (*data, m);
-  }
-  
-  p[-2] = ctr;
-}
-
-
-
-#ifdef USE_INTEL_VAES
-
-#if defined(__clang__) && defined(_MSC_VER)
-#define __SSE4_2__
-#define __AES__
-#define __AVX__
-#define __AVX2__
-#define __VAES__
-#define __AVX512F__
-#define __AVX512VL__
-#endif
-
-#include <immintrin.h>
-
-#define VAES_FUNC_START2(name) \
-AES_FUNC_START (name); \
-ATTRIB_VAES \
-AES_FUNC_START (name)
-
-VAES_FUNC_START2 (AesCbc_Decode_HW_256)
-{
-  __m128i iv = *p;
-  const __m128i *dataEnd;
-  UInt32 numRounds = *(const UInt32 *)(p + 1) * 2 + 1;
-  p += 2;
-  
-  WIDE_LOOP_START_AVX(;)
-  {
-    const __m256i *w = keys + numRounds - 2;
-    
-    WOP (AVX__DECLARE_VAR)
-    WOP (AVX__LOAD_data);
-    AVX__WOP_KEY (AVX__AES_XOR, 1)
-
-    do
-    {
-      AVX__WOP_KEY (AVX__AES_DEC, 0)
-      w--;
-    }
-    while (w != keys);
-    AVX__WOP_KEY (AVX__AES_DEC_LAST, 0)
-
-    AVX_XOR (m0, _mm256_setr_m128i(iv, data[0]));
-    WOP_M1 (AVX__XOR_data_M1)
-    iv = data[NUM_WAYS * 2 - 1];
-    WOP (AVX__STORE_data);
-  }
-  WIDE_LOOP_END_AVX(;)
-
-  SINGLE_LOOP
-  {
-    const __m128i *w = p + *(const UInt32 *)(p + 1 - 2) * 2 + 1 - 3;
-    __m128i m = _mm_xor_si128 (w[2], *data);
-    do
-    {
-      MM_OP_m (_mm_aesdec_si128, w[1]);
-      MM_OP_m (_mm_aesdec_si128, w[0]);
-      w -= 2;
-    }
-    while (w != p);
-    MM_OP_m (_mm_aesdec_si128,     w[1]);
-    MM_OP_m (_mm_aesdeclast_si128, w[0]);
-
-    MM_XOR (m, iv);
-    iv = *data;
-    *data = m;
-  }
-  
-  p[-2] = iv;
-}
-
-
-/*
-SSE2: _mm_cvtsi32_si128 : movd
-AVX:  _mm256_setr_m128i            : vinsertf128
-AVX2: _mm256_add_epi64             : vpaddq ymm, ymm, ymm
-      _mm256_extracti128_si256     : vextracti128
-      _mm256_broadcastsi128_si256  : vbroadcasti128
-*/
-
-#define AVX__CTR_LOOP_START  \
-    ctr2 = _mm256_setr_m128i(_mm_sub_epi64(ctr, one), ctr); \
-    two = _mm256_setr_m128i(one, one); \
-    two = _mm256_add_epi64(two, two); \
-
-// two = _mm256_setr_epi64x(2, 0, 2, 0);
-  
-#define AVX__CTR_LOOP_ENC  \
-    ctr = _mm256_extracti128_si256 (ctr2, 1); \
- 
-VAES_FUNC_START2 (AesCtr_Code_HW_256)
-{
-  __m128i ctr = *p;
-  UInt32 numRounds = *(const UInt32 *)(p + 1) * 2 + 1;
-  const __m128i *dataEnd;
-  __m128i one = _mm_cvtsi32_si128(1);
-  __m256i ctr2, two;
-  p += 2;
-  
-  WIDE_LOOP_START_AVX (AVX__CTR_LOOP_START)
-  {
-    const __m256i *w = keys;
-    UInt32 r = numRounds - 2;
-    WOP (AVX__DECLARE_VAR)
-    AVX__WOP_KEY (AVX__CTR_START, 0);
-
-    w += 1;
-    do
-    {
-      AVX__WOP_KEY (AVX__AES_ENC, 0)
-      w += 1;
-    }
-    while (--r);
-    AVX__WOP_KEY (AVX__AES_ENC_LAST, 0)
-   
-    WOP (AVX__CTR_END);
-  }
-  WIDE_LOOP_END_AVX (AVX__CTR_LOOP_ENC)
-  
-  SINGLE_LOOP
-  {
-    UInt32 numRounds2 = *(const UInt32 *)(p - 2 + 1) - 1;
-    const __m128i *w = p;
-    __m128i m;
-    MM_OP (_mm_add_epi64, ctr, one);
-    m = _mm_xor_si128 (ctr, p[0]);
-    w += 1;
-    do
-    {
-      MM_OP_m (_mm_aesenc_si128, w[0]);
-      MM_OP_m (_mm_aesenc_si128, w[1]);
-      w += 2;
-    }
-    while (--numRounds2);
-    MM_OP_m (_mm_aesenc_si128,     w[0]);
-    MM_OP_m (_mm_aesenclast_si128, w[1]);
-    MM_XOR (*data, m);
-  }
-
-  p[-2] = ctr;
-}
-
-#endif // USE_INTEL_VAES
-
-#else // USE_INTEL_AES
-
-/* no USE_INTEL_AES */
-
-#pragma message("AES  HW_SW stub was used")
-
-#define AES_TYPE_keys UInt32
-#define AES_TYPE_data Byte
-
-#define AES_FUNC_START(name) \
-    void MY_FAST_CALL name(UInt32 *p, Byte *data, size_t numBlocks) \
-
-#define AES_COMPAT_STUB(name) \
-    AES_FUNC_START(name); \
-    AES_FUNC_START(name ## _HW) \
-    { name(p, data, numBlocks); }
-
-AES_COMPAT_STUB (AesCbc_Encode)
-AES_COMPAT_STUB (AesCbc_Decode)
-AES_COMPAT_STUB (AesCtr_Code)
-
-#endif // USE_INTEL_AES
-
-
-#ifndef USE_INTEL_VAES
-
-#pragma message("VAES HW_SW stub was used")
-
-#define VAES_COMPAT_STUB(name) \
-    void MY_FAST_CALL name ## _256(UInt32 *p, Byte *data, size_t numBlocks); \
-    void MY_FAST_CALL name ## _256(UInt32 *p, Byte *data, size_t numBlocks) \
-    { name((AES_TYPE_keys *)(void *)p, (AES_TYPE_data *)(void *)data, numBlocks); }
-
-VAES_COMPAT_STUB (AesCbc_Decode_HW)
-VAES_COMPAT_STUB (AesCtr_Code_HW)
-
-#endif // ! USE_INTEL_VAES
-
-
-#elif defined(MY_CPU_ARM_OR_ARM64) && defined(MY_CPU_LE)
-
-  #if defined(__clang__)
-    #if (__clang_major__ >= 8) // fix that check
-      #define USE_HW_AES
-    #endif
-  #elif defined(__GNUC__)
-    #if (__GNUC__ >= 6) // fix that check
-      #define USE_HW_AES
-    #endif
-  #elif defined(_MSC_VER)
-    #if _MSC_VER >= 1910
-      #define USE_HW_AES
-    #endif
-  #endif
-
-#ifdef USE_HW_AES
-
-// #pragma message("=== AES HW === ")
-
-#if defined(__clang__) || defined(__GNUC__)
-  #ifdef MY_CPU_ARM64
-    #define ATTRIB_AES __attribute__((__target__("+crypto")))
-  #else
-    #define ATTRIB_AES __attribute__((__target__("fpu=crypto-neon-fp-armv8")))
-  #endif
-#else
-  // _MSC_VER
-  // for arm32
-  #define _ARM_USE_NEW_NEON_INTRINSICS
-#endif
-
-#ifndef ATTRIB_AES
-  #define ATTRIB_AES
-#endif
-
-#if defined(_MSC_VER) && defined(MY_CPU_ARM64)
-#include <arm64_neon.h>
-#else
-#include <arm_neon.h>
-#endif
-
-typedef uint8x16_t v128;
-
-#define AES_FUNC_START(name) \
-    void MY_FAST_CALL name(v128 *p, v128 *data, size_t numBlocks)
-
-#define AES_FUNC_START2(name) \
-AES_FUNC_START (name); \
-ATTRIB_AES \
-AES_FUNC_START (name)
-
-#define MM_OP(op, dest, src)  dest = op(dest, src);
-#define MM_OP_m(op, src)      MM_OP(op, m, src);
-#define MM_OP1_m(op)          m = op(m);
-
-#define MM_XOR( dest, src)    MM_OP(veorq_u8, dest, src);
-#define MM_XOR_m( src)        MM_XOR(m, src);
-
-#define AES_E_m(k)     MM_OP_m (vaeseq_u8, k);
-#define AES_E_MC_m(k)  AES_E_m (k);  MM_OP1_m(vaesmcq_u8);
-
-
-AES_FUNC_START2 (AesCbc_Encode_HW)
-{
-  v128 m = *p;
-  const v128 k0 = p[2];
-  const v128 k1 = p[3];
-  const v128 k2 = p[4];
-  const v128 k3 = p[5];
-  const v128 k4 = p[6];
-  const v128 k5 = p[7];
-  const v128 k6 = p[8];
-  const v128 k7 = p[9];
-  const v128 k8 = p[10];
-  const v128 k9 = p[11];
-  const UInt32 numRounds2 = *(const UInt32 *)(p + 1);
-  const v128 *w = p + ((size_t)numRounds2 * 2);
-  const v128 k_z1 = w[1];
-  const v128 k_z0 = w[2];
-  for (; numBlocks != 0; numBlocks--, data++)
-  {
-    MM_XOR_m (*data);
-    AES_E_MC_m (k0)
-    AES_E_MC_m (k1)
-    AES_E_MC_m (k2)
-    AES_E_MC_m (k3)
-    AES_E_MC_m (k4)
-    AES_E_MC_m (k5)
-    AES_E_MC_m (k6)
-    AES_E_MC_m (k7)
-    AES_E_MC_m (k8)
-    if (numRounds2 >= 6)
-    {
-      AES_E_MC_m (k9)
-      AES_E_MC_m (p[12])
-      if (numRounds2 != 6)
-      {
-        AES_E_MC_m (p[13])
-        AES_E_MC_m (p[14])
-      }
-    }
-    AES_E_m  (k_z1);
-    MM_XOR_m (k_z0);
-    *data = m;
-  }
-  *p = m;
-}
-
-
-#define WOP_1(op)
-#define WOP_2(op)   WOP_1 (op)  op (m1, 1);
-#define WOP_3(op)   WOP_2 (op)  op (m2, 2);
-#define WOP_4(op)   WOP_3 (op)  op (m3, 3);
-#define WOP_5(op)   WOP_4 (op)  op (m4, 4);
-#define WOP_6(op)   WOP_5 (op)  op (m5, 5);
-#define WOP_7(op)   WOP_6 (op)  op (m6, 6);
-#define WOP_8(op)   WOP_7 (op)  op (m7, 7);
-
-  #define NUM_WAYS      8
-  #define WOP_M1    WOP_8
-
-#define WOP(op)  op (m0, 0);  WOP_M1(op)
-
-#define DECLARE_VAR(reg, ii)  v128 reg
-#define LOAD_data(  reg, ii)  reg = data[ii];
-#define STORE_data( reg, ii)  data[ii] = reg;
-#if (NUM_WAYS > 1)
-#define XOR_data_M1(reg, ii)  MM_XOR (reg, data[ii- 1]);
-#endif
-
-#define MM_OP_key(op, reg)  MM_OP (op, reg, key);
-
-#define AES_D_m(k)      MM_OP_m (vaesdq_u8, k);
-#define AES_D_IMC_m(k)  AES_D_m (k);  MM_OP1_m (vaesimcq_u8);
-
-#define AES_XOR(   reg, ii)  MM_OP_key (veorq_u8,  reg)
-#define AES_D(     reg, ii)  MM_OP_key (vaesdq_u8, reg)
-#define AES_E(     reg, ii)  MM_OP_key (vaeseq_u8, reg)
-
-#define AES_D_IMC( reg, ii)  AES_D (reg, ii);  reg = vaesimcq_u8(reg)
-#define AES_E_MC(  reg, ii)  AES_E (reg, ii);  reg = vaesmcq_u8(reg)
-
-#define CTR_START(reg, ii)  MM_OP (vaddq_u64, ctr, one);  reg = vreinterpretq_u8_u64(ctr);
-#define CTR_END(  reg, ii)  MM_XOR (data[ii], reg);
-
-#define WOP_KEY(op, n) { \
-    const v128 key = w[n]; \
-    WOP(op); }
-
-#define WIDE_LOOP_START  \
-    dataEnd = data + numBlocks;  \
-    if (numBlocks >= NUM_WAYS)  \
-    { dataEnd -= NUM_WAYS; do {  \
-
-#define WIDE_LOOP_END  \
-    data += NUM_WAYS;  \
-    } while (data <= dataEnd);  \
-    dataEnd += NUM_WAYS; }  \
-
-#define SINGLE_LOOP  \
-    for (; data < dataEnd; data++)
-
-
-AES_FUNC_START2 (AesCbc_Decode_HW)
-{
-  v128 iv = *p;
-  const v128 *wStart = p + ((size_t)*(const UInt32 *)(p + 1)) * 2;
-  const v128 *dataEnd;
-  p += 2;
-  
-  WIDE_LOOP_START
-  {
-    const v128 *w = wStart;
-    WOP (DECLARE_VAR)
-    WOP (LOAD_data);
-    WOP_KEY (AES_D_IMC, 2)
-    do
-    {
-      WOP_KEY (AES_D_IMC, 1)
-      WOP_KEY (AES_D_IMC, 0)
-      w -= 2;
-    }
-    while (w != p);
-    WOP_KEY (AES_D,   1)
-    WOP_KEY (AES_XOR, 0)
-    MM_XOR (m0, iv);
-    WOP_M1 (XOR_data_M1)
-    iv = data[NUM_WAYS - 1];
-    WOP (STORE_data);
-  }
-  WIDE_LOOP_END
-
-  SINGLE_LOOP
-  {
-    const v128 *w = wStart;
-    v128 m = *data;
-    AES_D_IMC_m (w[2])
-    do
-    {
-      AES_D_IMC_m (w[1]);
-      AES_D_IMC_m (w[0]);
-      w -= 2;
-    }
-    while (w != p);
-    AES_D_m  (w[1]);
-    MM_XOR_m (w[0]);
-    MM_XOR_m (iv);
-    iv = *data;
-    *data = m;
-  }
-  
-  p[-2] = iv;
-}
-
-
-AES_FUNC_START2 (AesCtr_Code_HW)
-{
-  uint64x2_t ctr = vreinterpretq_u64_u8(*p);
-  const v128 *wEnd = p + ((size_t)*(const UInt32 *)(p + 1)) * 2;
-  const v128 *dataEnd;
-  uint64x2_t one = vdupq_n_u64(0);
-  one = vsetq_lane_u64(1, one, 0);
-  p += 2;
-  
-  WIDE_LOOP_START
-  {
-    const v128 *w = p;
-    WOP (DECLARE_VAR)
-    WOP (CTR_START);
-    do
-    {
-      WOP_KEY (AES_E_MC, 0)
-      WOP_KEY (AES_E_MC, 1)
-      w += 2;
-    }
-    while (w != wEnd);
-    WOP_KEY (AES_E_MC, 0)
-    WOP_KEY (AES_E,    1)
-    WOP_KEY (AES_XOR,  2)
-    WOP (CTR_END);
-  }
-  WIDE_LOOP_END
-
-  SINGLE_LOOP
-  {
-    const v128 *w = p;
-    v128 m;
-    CTR_START (m, 0);
-    do
-    {
-      AES_E_MC_m (w[0]);
-      AES_E_MC_m (w[1]);
-      w += 2;
-    }
-    while (w != wEnd);
-    AES_E_MC_m (w[0]);
-    AES_E_m    (w[1]);
-    MM_XOR_m   (w[2]);
-    CTR_END (m, 0);
-  }
-  
-  p[-2] = vreinterpretq_u8_u64(ctr);
-}
-
-#endif // USE_HW_AES
-
-#endif // MY_CPU_ARM_OR_ARM64

3rdparty/7z/src/Alloc.c

@@ -1,463 +0,0 @@
-/* Alloc.c -- Memory allocation functions
-2021-07-13 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include <stdio.h>
-
-#ifdef _WIN32
-#include <Windows.h>
-#endif
-#include <stdlib.h>
-
-#include "Alloc.h"
-
-/* #define _SZ_ALLOC_DEBUG */
-
-/* use _SZ_ALLOC_DEBUG to debug alloc/free operations */
-#ifdef _SZ_ALLOC_DEBUG
-
-#include <stdio.h>
-int g_allocCount = 0;
-int g_allocCountMid = 0;
-int g_allocCountBig = 0;
-
-
-#define CONVERT_INT_TO_STR(charType, tempSize) \
-  unsigned char temp[tempSize]; unsigned i = 0; \
-  while (val >= 10) { temp[i++] = (unsigned char)('0' + (unsigned)(val % 10)); val /= 10; } \
-  *s++ = (charType)('0' + (unsigned)val); \
-  while (i != 0) { i--; *s++ = temp[i]; } \
-  *s = 0;
-
-static void ConvertUInt64ToString(UInt64 val, char *s)
-{
-  CONVERT_INT_TO_STR(char, 24);
-}
-
-#define GET_HEX_CHAR(t) ((char)(((t < 10) ? ('0' + t) : ('A' + (t - 10)))))
-
-static void ConvertUInt64ToHex(UInt64 val, char *s)
-{
-  UInt64 v = val;
-  unsigned i;
-  for (i = 1;; i++)
-  {
-    v >>= 4;
-    if (v == 0)
-      break;
-  }
-  s[i] = 0;
-  do
-  {
-    unsigned t = (unsigned)(val & 0xF);
-    val >>= 4;
-    s[--i] = GET_HEX_CHAR(t);
-  }
-  while (i);
-}
-
-#define DEBUG_OUT_STREAM stderr
-
-static void Print(const char *s)
-{
-  fputs(s, DEBUG_OUT_STREAM);
-}
-
-static void PrintAligned(const char *s, size_t align)
-{
-  size_t len = strlen(s);
-  for(;;)
-  {
-    fputc(' ', DEBUG_OUT_STREAM);
-    if (len >= align)
-      break;
-    ++len;
-  }
-  Print(s);
-}
-
-static void PrintLn()
-{
-  Print("\n");
-}
-
-static void PrintHex(UInt64 v, size_t align)
-{
-  char s[32];
-  ConvertUInt64ToHex(v, s);
-  PrintAligned(s, align);
-}
-
-static void PrintDec(UInt64 v, size_t align)
-{
-  char s[32];
-  ConvertUInt64ToString(v, s);
-  PrintAligned(s, align);
-}
-
-static void PrintAddr(void *p)
-{
-  PrintHex((UInt64)(size_t)(ptrdiff_t)p, 12);
-}
-
-
-#define PRINT_ALLOC(name, cnt, size, ptr) \
-    Print(name " "); \
-    PrintDec(cnt++, 10); \
-    PrintHex(size, 10); \
-    PrintAddr(ptr); \
-    PrintLn();
- 
-#define PRINT_FREE(name, cnt, ptr) if (ptr) { \
-    Print(name " "); \
-    PrintDec(--cnt, 10); \
-    PrintAddr(ptr); \
-    PrintLn(); }
- 
-#else
-
-#define PRINT_ALLOC(name, cnt, size, ptr)
-#define PRINT_FREE(name, cnt, ptr)
-#define Print(s)
-#define PrintLn()
-#define PrintHex(v, align)
-#define PrintAddr(p)
-
-#endif
-
-
-
-void *MyAlloc(size_t size)
-{
-  if (size == 0)
-    return NULL;
-  PRINT_ALLOC("Alloc    ", g_allocCount, size, NULL);
-  #ifdef _SZ_ALLOC_DEBUG
-  {
-    void *p = malloc(size);
-    // PRINT_ALLOC("Alloc    ", g_allocCount, size, p);
-    return p;
-  }
-  #else
-  return malloc(size);
-  #endif
-}
-
-void MyFree(void *address)
-{
-  PRINT_FREE("Free    ", g_allocCount, address);
-  
-  free(address);
-}
-
-#ifdef _WIN32
-
-void *MidAlloc(size_t size)
-{
-  if (size == 0)
-    return NULL;
-  
-  PRINT_ALLOC("Alloc-Mid", g_allocCountMid, size, NULL);
-  
-  return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
-}
-
-void MidFree(void *address)
-{
-  PRINT_FREE("Free-Mid", g_allocCountMid, address);
-
-  if (!address)
-    return;
-  VirtualFree(address, 0, MEM_RELEASE);
-}
-
-#ifdef _7ZIP_LARGE_PAGES
-
-#ifdef MEM_LARGE_PAGES
-  #define MY__MEM_LARGE_PAGES  MEM_LARGE_PAGES
-#else
-  #define MY__MEM_LARGE_PAGES  0x20000000
-#endif
-
-extern
-SIZE_T g_LargePageSize;
-SIZE_T g_LargePageSize = 0;
-typedef SIZE_T (WINAPI *GetLargePageMinimumP)(VOID);
-
-#endif // _7ZIP_LARGE_PAGES
-
-void SetLargePageSize()
-{
-  #ifdef _7ZIP_LARGE_PAGES
-  SIZE_T size;
-  GetLargePageMinimumP largePageMinimum = (GetLargePageMinimumP)
-        GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "GetLargePageMinimum");
-  if (!largePageMinimum)
-    return;
-  size = largePageMinimum();
-  if (size == 0 || (size & (size - 1)) != 0)
-    return;
-  g_LargePageSize = size;
-  #endif
-}
-
-
-void *BigAlloc(size_t size)
-{
-  if (size == 0)
-    return NULL;
-
-  PRINT_ALLOC("Alloc-Big", g_allocCountBig, size, NULL);
-  
-  #ifdef _7ZIP_LARGE_PAGES
-  {
-    SIZE_T ps = g_LargePageSize;
-    if (ps != 0 && ps <= (1 << 30) && size > (ps / 2))
-    {
-      size_t size2;
-      ps--;
-      size2 = (size + ps) & ~ps;
-      if (size2 >= size)
-      {
-        void *res = VirtualAlloc(NULL, size2, MEM_COMMIT | MY__MEM_LARGE_PAGES, PAGE_READWRITE);
-        if (res)
-          return res;
-      }
-    }
-  }
-  #endif
-
-  return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
-}
-
-void BigFree(void *address)
-{
-  PRINT_FREE("Free-Big", g_allocCountBig, address);
-  
-  if (!address)
-    return;
-  VirtualFree(address, 0, MEM_RELEASE);
-}
-
-#endif
-
-
-static void *SzAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p); return MyAlloc(size); }
-static void SzFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p); MyFree(address); }
-const ISzAlloc g_Alloc = { SzAlloc, SzFree };
-
-#ifdef _WIN32
-static void *SzMidAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p); return MidAlloc(size); }
-static void SzMidFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p); MidFree(address); }
-static void *SzBigAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p); return BigAlloc(size); }
-static void SzBigFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p); BigFree(address); }
-const ISzAlloc g_MidAlloc = { SzMidAlloc, SzMidFree };
-const ISzAlloc g_BigAlloc = { SzBigAlloc, SzBigFree };
-#endif
-
-/*
-  uintptr_t : <stdint.h> C99 (optional)
-            : unsupported in VS6
-*/
-
-#ifdef _WIN32
-  typedef UINT_PTR UIntPtr;
-#else
-  /*
-  typedef uintptr_t UIntPtr;
-  */
-  typedef ptrdiff_t UIntPtr;
-#endif
-
-
-#define ADJUST_ALLOC_SIZE 0
-/*
-#define ADJUST_ALLOC_SIZE (sizeof(void *) - 1)
-*/
-/*
-  Use (ADJUST_ALLOC_SIZE = (sizeof(void *) - 1)), if
-     MyAlloc() can return address that is NOT multiple of sizeof(void *).
-*/
-
-
-/*
-#define MY_ALIGN_PTR_DOWN(p, align) ((void *)((char *)(p) - ((size_t)(UIntPtr)(p) & ((align) - 1))))
-*/
-#define MY_ALIGN_PTR_DOWN(p, align) ((void *)((((UIntPtr)(p)) & ~((UIntPtr)(align) - 1))))
-
-
-#if !defined(_WIN32) && defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200112L)
-  #define USE_posix_memalign
-#endif
-
-#ifndef USE_posix_memalign
-#define MY_ALIGN_PTR_UP_PLUS(p, align) MY_ALIGN_PTR_DOWN(((char *)(p) + (align) + ADJUST_ALLOC_SIZE), align)
-#endif
-
-/*
-  This posix_memalign() is for test purposes only.
-  We also need special Free() function instead of free(),
-  if this posix_memalign() is used.
-*/
-
-/*
-static int posix_memalign(void **ptr, size_t align, size_t size)
-{
-  size_t newSize = size + align;
-  void *p;
-  void *pAligned;
-  *ptr = NULL;
-  if (newSize < size)
-    return 12; // ENOMEM
-  p = MyAlloc(newSize);
-  if (!p)
-    return 12; // ENOMEM
-  pAligned = MY_ALIGN_PTR_UP_PLUS(p, align);
-  ((void **)pAligned)[-1] = p;
-  *ptr = pAligned;
-  return 0;
-}
-*/
-
-/*
-  ALLOC_ALIGN_SIZE >= sizeof(void *)
-  ALLOC_ALIGN_SIZE >= cache_line_size
-*/
-
-#define ALLOC_ALIGN_SIZE ((size_t)1 << 7)
-
-static void *SzAlignedAlloc(ISzAllocPtr pp, size_t size)
-{
-  #ifndef USE_posix_memalign
-  
-  void *p;
-  void *pAligned;
-  size_t newSize;
-  UNUSED_VAR(pp);
-
-  /* also we can allocate additional dummy ALLOC_ALIGN_SIZE bytes after aligned
-     block to prevent cache line sharing with another allocated blocks */
-
-  newSize = size + ALLOC_ALIGN_SIZE * 1 + ADJUST_ALLOC_SIZE;
-  if (newSize < size)
-    return NULL;
-
-  p = MyAlloc(newSize);
-  
-  if (!p)
-    return NULL;
-  pAligned = MY_ALIGN_PTR_UP_PLUS(p, ALLOC_ALIGN_SIZE);
-
-  Print(" size="); PrintHex(size, 8);
-  Print(" a_size="); PrintHex(newSize, 8);
-  Print(" ptr="); PrintAddr(p);
-  Print(" a_ptr="); PrintAddr(pAligned);
-  PrintLn();
-
-  ((void **)pAligned)[-1] = p;
-
-  return pAligned;
-
-  #else
-
-  void *p;
-  UNUSED_VAR(pp);
-  if (posix_memalign(&p, ALLOC_ALIGN_SIZE, size))
-    return NULL;
-
-  Print(" posix_memalign="); PrintAddr(p);
-  PrintLn();
-
-  return p;
-
-  #endif
-}
-
-
-static void SzAlignedFree(ISzAllocPtr pp, void *address)
-{
-  UNUSED_VAR(pp);
-  #ifndef USE_posix_memalign
-  if (address)
-    MyFree(((void **)address)[-1]);
-  #else
-  free(address);
-  #endif
-}
-
-
-const ISzAlloc g_AlignedAlloc = { SzAlignedAlloc, SzAlignedFree };
-
-
-
-#define MY_ALIGN_PTR_DOWN_1(p) MY_ALIGN_PTR_DOWN(p, sizeof(void *))
-
-/* we align ptr to support cases where CAlignOffsetAlloc::offset is not multiply of sizeof(void *) */
-#define REAL_BLOCK_PTR_VAR(p) ((void **)MY_ALIGN_PTR_DOWN_1(p))[-1]
-/*
-#define REAL_BLOCK_PTR_VAR(p) ((void **)(p))[-1]
-*/
-
-static void *AlignOffsetAlloc_Alloc(ISzAllocPtr pp, size_t size)
-{
-  CAlignOffsetAlloc *p = CONTAINER_FROM_VTBL(pp, CAlignOffsetAlloc, vt);
-  void *adr;
-  void *pAligned;
-  size_t newSize;
-  size_t extra;
-  size_t alignSize = (size_t)1 << p->numAlignBits;
-
-  if (alignSize < sizeof(void *))
-    alignSize = sizeof(void *);
-  
-  if (p->offset >= alignSize)
-    return NULL;
-
-  /* also we can allocate additional dummy ALLOC_ALIGN_SIZE bytes after aligned
-     block to prevent cache line sharing with another allocated blocks */
-  extra = p->offset & (sizeof(void *) - 1);
-  newSize = size + alignSize + extra + ADJUST_ALLOC_SIZE;
-  if (newSize < size)
-    return NULL;
-
-  adr = ISzAlloc_Alloc(p->baseAlloc, newSize);
-  
-  if (!adr)
-    return NULL;
-
-  pAligned = (char *)MY_ALIGN_PTR_DOWN((char *)adr +
-      alignSize - p->offset + extra + ADJUST_ALLOC_SIZE, alignSize) + p->offset;
-
-  PrintLn();
-  Print("- Aligned: ");
-  Print(" size="); PrintHex(size, 8);
-  Print(" a_size="); PrintHex(newSize, 8);
-  Print(" ptr="); PrintAddr(adr);
-  Print(" a_ptr="); PrintAddr(pAligned);
-  PrintLn();
-
-  REAL_BLOCK_PTR_VAR(pAligned) = adr;
-
-  return pAligned;
-}
-
-
-static void AlignOffsetAlloc_Free(ISzAllocPtr pp, void *address)
-{
-  if (address)
-  {
-    CAlignOffsetAlloc *p = CONTAINER_FROM_VTBL(pp, CAlignOffsetAlloc, vt);
-    PrintLn();
-    Print("- Aligned Free: ");
-    PrintLn();
-    ISzAlloc_Free(p->baseAlloc, REAL_BLOCK_PTR_VAR(address));
-  }
-}
-
-
-void AlignOffsetAlloc_CreateVTable(CAlignOffsetAlloc *p)
-{
-  p->vt.Alloc = AlignOffsetAlloc_Alloc;
-  p->vt.Free = AlignOffsetAlloc_Free;
-}

3rdparty/7z/src/Alloc.h

@@ -1,58 +0,0 @@
-/* Alloc.h -- Memory allocation functions
-2021-07-13 : Igor Pavlov : Public domain */
-
-#ifndef __COMMON_ALLOC_H
-#define __COMMON_ALLOC_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-void *MyAlloc(size_t size);
-void MyFree(void *address);
-
-#ifdef _WIN32
-
-void SetLargePageSize(void);
-
-void *MidAlloc(size_t size);
-void MidFree(void *address);
-void *BigAlloc(size_t size);
-void BigFree(void *address);
-
-#else
-
-#define MidAlloc(size) MyAlloc(size)
-#define MidFree(address) MyFree(address)
-#define BigAlloc(size) MyAlloc(size)
-#define BigFree(address) MyFree(address)
-
-#endif
-
-extern const ISzAlloc g_Alloc;
-
-#ifdef _WIN32
-extern const ISzAlloc g_BigAlloc;
-extern const ISzAlloc g_MidAlloc;
-#else
-#define g_BigAlloc g_AlignedAlloc
-#define g_MidAlloc g_AlignedAlloc
-#endif
-
-extern const ISzAlloc g_AlignedAlloc;
-
-
-typedef struct
-{
-  ISzAlloc vt;
-  ISzAllocPtr baseAlloc;
-  unsigned numAlignBits; /* ((1 << numAlignBits) >= sizeof(void *)) */
-  size_t offset;         /* (offset == (k * sizeof(void *)) && offset < (1 << numAlignBits) */
-} CAlignOffsetAlloc;
-
-void AlignOffsetAlloc_CreateVTable(CAlignOffsetAlloc *p);
-
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/Bcj2.c

@@ -1,257 +0,0 @@
-/* Bcj2.c -- BCJ2 Decoder (Converter for x86 code)
-2021-02-09 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "Bcj2.h"
-#include "CpuArch.h"
-
-#define CProb UInt16
-
-#define kTopValue ((UInt32)1 << 24)
-#define kNumModelBits 11
-#define kBitModelTotal (1 << kNumModelBits)
-#define kNumMoveBits 5
-
-#define _IF_BIT_0 ttt = *prob; bound = (p->range >> kNumModelBits) * ttt; if (p->code < bound)
-#define _UPDATE_0 p->range = bound; *prob = (CProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));
-#define _UPDATE_1 p->range -= bound; p->code -= bound; *prob = (CProb)(ttt - (ttt >> kNumMoveBits));
-
-void Bcj2Dec_Init(CBcj2Dec *p)
-{
-  unsigned i;
-
-  p->state = BCJ2_DEC_STATE_OK;
-  p->ip = 0;
-  p->temp[3] = 0;
-  p->range = 0;
-  p->code = 0;
-  for (i = 0; i < sizeof(p->probs) / sizeof(p->probs[0]); i++)
-    p->probs[i] = kBitModelTotal >> 1;
-}
-
-SRes Bcj2Dec_Decode(CBcj2Dec *p)
-{
-  if (p->range <= 5)
-  {
-    p->state = BCJ2_DEC_STATE_OK;
-    for (; p->range != 5; p->range++)
-    {
-      if (p->range == 1 && p->code != 0)
-        return SZ_ERROR_DATA;
-      
-      if (p->bufs[BCJ2_STREAM_RC] == p->lims[BCJ2_STREAM_RC])
-      {
-        p->state = BCJ2_STREAM_RC;
-        return SZ_OK;
-      }
-
-      p->code = (p->code << 8) | *(p->bufs[BCJ2_STREAM_RC])++;
-    }
-    
-    if (p->code == 0xFFFFFFFF)
-      return SZ_ERROR_DATA;
-    
-    p->range = 0xFFFFFFFF;
-  }
-  else if (p->state >= BCJ2_DEC_STATE_ORIG_0)
-  {
-    while (p->state <= BCJ2_DEC_STATE_ORIG_3)
-    {
-      Byte *dest = p->dest;
-      if (dest == p->destLim)
-        return SZ_OK;
-      *dest = p->temp[(size_t)p->state - BCJ2_DEC_STATE_ORIG_0];
-      p->state++;
-      p->dest = dest + 1;
-    }
-  }
-
-  /*
-  if (BCJ2_IS_32BIT_STREAM(p->state))
-  {
-    const Byte *cur = p->bufs[p->state];
-    if (cur == p->lims[p->state])
-      return SZ_OK;
-    p->bufs[p->state] = cur + 4;
-    
-    {
-      UInt32 val;
-      Byte *dest;
-      SizeT rem;
-      
-      p->ip += 4;
-      val = GetBe32(cur) - p->ip;
-      dest = p->dest;
-      rem = p->destLim - dest;
-      if (rem < 4)
-      {
-        SizeT i;
-        SetUi32(p->temp, val);
-        for (i = 0; i < rem; i++)
-          dest[i] = p->temp[i];
-        p->dest = dest + rem;
-        p->state = BCJ2_DEC_STATE_ORIG_0 + (unsigned)rem;
-        return SZ_OK;
-      }
-      SetUi32(dest, val);
-      p->temp[3] = (Byte)(val >> 24);
-      p->dest = dest + 4;
-      p->state = BCJ2_DEC_STATE_OK;
-    }
-  }
-  */
-
-  for (;;)
-  {
-    if (BCJ2_IS_32BIT_STREAM(p->state))
-      p->state = BCJ2_DEC_STATE_OK;
-    else
-    {
-      if (p->range < kTopValue)
-      {
-        if (p->bufs[BCJ2_STREAM_RC] == p->lims[BCJ2_STREAM_RC])
-        {
-          p->state = BCJ2_STREAM_RC;
-          return SZ_OK;
-        }
-        p->range <<= 8;
-        p->code = (p->code << 8) | *(p->bufs[BCJ2_STREAM_RC])++;
-      }
-
-      {
-        const Byte *src = p->bufs[BCJ2_STREAM_MAIN];
-        const Byte *srcLim;
-        Byte *dest;
-        SizeT num = (SizeT)(p->lims[BCJ2_STREAM_MAIN] - src);
-        
-        if (num == 0)
-        {
-          p->state = BCJ2_STREAM_MAIN;
-          return SZ_OK;
-        }
-        
-        dest = p->dest;
-        if (num > (SizeT)(p->destLim - dest))
-        {
-          num = (SizeT)(p->destLim - dest);
-          if (num == 0)
-          {
-            p->state = BCJ2_DEC_STATE_ORIG;
-            return SZ_OK;
-          }
-        }
-       
-        srcLim = src + num;
-
-        if (p->temp[3] == 0x0F && (src[0] & 0xF0) == 0x80)
-          *dest = src[0];
-        else for (;;)
-        {
-          Byte b = *src;
-          *dest = b;
-          if (b != 0x0F)
-          {
-            if ((b & 0xFE) == 0xE8)
-              break;
-            dest++;
-            if (++src != srcLim)
-              continue;
-            break;
-          }
-          dest++;
-          if (++src == srcLim)
-            break;
-          if ((*src & 0xF0) != 0x80)
-            continue;
-          *dest = *src;
-          break;
-        }
-        
-        num = (SizeT)(src - p->bufs[BCJ2_STREAM_MAIN]);
-        
-        if (src == srcLim)
-        {
-          p->temp[3] = src[-1];
-          p->bufs[BCJ2_STREAM_MAIN] = src;
-          p->ip += (UInt32)num;
-          p->dest += num;
-          p->state =
-            p->bufs[BCJ2_STREAM_MAIN] ==
-            p->lims[BCJ2_STREAM_MAIN] ?
-              (unsigned)BCJ2_STREAM_MAIN :
-              (unsigned)BCJ2_DEC_STATE_ORIG;
-          return SZ_OK;
-        }
-        
-        {
-          UInt32 bound, ttt;
-          CProb *prob;
-          Byte b = src[0];
-          Byte prev = (Byte)(num == 0 ? p->temp[3] : src[-1]);
-          
-          p->temp[3] = b;
-          p->bufs[BCJ2_STREAM_MAIN] = src + 1;
-          num++;
-          p->ip += (UInt32)num;
-          p->dest += num;
-          
-          prob = p->probs + (unsigned)(b == 0xE8 ? 2 + (unsigned)prev : (b == 0xE9 ? 1 : 0));
-          
-          _IF_BIT_0
-          {
-            _UPDATE_0
-            continue;
-          }
-          _UPDATE_1
-            
-        }
-      }
-    }
-
-    {
-      UInt32 val;
-      unsigned cj = (p->temp[3] == 0xE8) ? BCJ2_STREAM_CALL : BCJ2_STREAM_JUMP;
-      const Byte *cur = p->bufs[cj];
-      Byte *dest;
-      SizeT rem;
-      
-      if (cur == p->lims[cj])
-      {
-        p->state = cj;
-        break;
-      }
-      
-      val = GetBe32(cur);
-      p->bufs[cj] = cur + 4;
-
-      p->ip += 4;
-      val -= p->ip;
-      dest = p->dest;
-      rem = (SizeT)(p->destLim - dest);
-      
-      if (rem < 4)
-      {
-        p->temp[0] = (Byte)val; if (rem > 0) dest[0] = (Byte)val; val >>= 8;
-        p->temp[1] = (Byte)val; if (rem > 1) dest[1] = (Byte)val; val >>= 8;
-        p->temp[2] = (Byte)val; if (rem > 2) dest[2] = (Byte)val; val >>= 8;
-        p->temp[3] = (Byte)val;
-        p->dest = dest + rem;
-        p->state = BCJ2_DEC_STATE_ORIG_0 + (unsigned)rem;
-        break;
-      }
-      
-      SetUi32(dest, val);
-      p->temp[3] = (Byte)(val >> 24);
-      p->dest = dest + 4;
-    }
-  }
-
-  if (p->range < kTopValue && p->bufs[BCJ2_STREAM_RC] != p->lims[BCJ2_STREAM_RC])
-  {
-    p->range <<= 8;
-    p->code = (p->code << 8) | *(p->bufs[BCJ2_STREAM_RC])++;
-  }
-
-  return SZ_OK;
-}

3rdparty/7z/src/Bcj2.h

@@ -1,146 +0,0 @@
-/* Bcj2.h -- BCJ2 Converter for x86 code
-2014-11-10 : Igor Pavlov : Public domain */
-
-#ifndef __BCJ2_H
-#define __BCJ2_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-#define BCJ2_NUM_STREAMS 4
-
-enum
-{
-  BCJ2_STREAM_MAIN,
-  BCJ2_STREAM_CALL,
-  BCJ2_STREAM_JUMP,
-  BCJ2_STREAM_RC
-};
-
-enum
-{
-  BCJ2_DEC_STATE_ORIG_0 = BCJ2_NUM_STREAMS,
-  BCJ2_DEC_STATE_ORIG_1,
-  BCJ2_DEC_STATE_ORIG_2,
-  BCJ2_DEC_STATE_ORIG_3,
-  
-  BCJ2_DEC_STATE_ORIG,
-  BCJ2_DEC_STATE_OK
-};
-
-enum
-{
-  BCJ2_ENC_STATE_ORIG = BCJ2_NUM_STREAMS,
-  BCJ2_ENC_STATE_OK
-};
-
-
-#define BCJ2_IS_32BIT_STREAM(s) ((s) == BCJ2_STREAM_CALL || (s) == BCJ2_STREAM_JUMP)
-
-/*
-CBcj2Dec / CBcj2Enc
-bufs sizes:
-  BUF_SIZE(n) = lims[n] - bufs[n]
-bufs sizes for BCJ2_STREAM_CALL and BCJ2_STREAM_JUMP must be mutliply of 4:
-    (BUF_SIZE(BCJ2_STREAM_CALL) & 3) == 0
-    (BUF_SIZE(BCJ2_STREAM_JUMP) & 3) == 0
-*/
-
-/*
-CBcj2Dec:
-dest is allowed to overlap with bufs[BCJ2_STREAM_MAIN], with the following conditions:
-  bufs[BCJ2_STREAM_MAIN] >= dest &&
-  bufs[BCJ2_STREAM_MAIN] - dest >= tempReserv +
-        BUF_SIZE(BCJ2_STREAM_CALL) +
-        BUF_SIZE(BCJ2_STREAM_JUMP)
-     tempReserv = 0 : for first call of Bcj2Dec_Decode
-     tempReserv = 4 : for any other calls of Bcj2Dec_Decode
-  overlap with offset = 1 is not allowed
-*/
-
-typedef struct
-{
-  const Byte *bufs[BCJ2_NUM_STREAMS];
-  const Byte *lims[BCJ2_NUM_STREAMS];
-  Byte *dest;
-  const Byte *destLim;
-
-  unsigned state; /* BCJ2_STREAM_MAIN has more priority than BCJ2_STATE_ORIG */
-
-  UInt32 ip;
-  Byte temp[4];
-  UInt32 range;
-  UInt32 code;
-  UInt16 probs[2 + 256];
-} CBcj2Dec;
-
-void Bcj2Dec_Init(CBcj2Dec *p);
-
-/* Returns: SZ_OK or SZ_ERROR_DATA */
-SRes Bcj2Dec_Decode(CBcj2Dec *p);
-
-#define Bcj2Dec_IsFinished(_p_) ((_p_)->code == 0)
-
-
-
-typedef enum
-{
-  BCJ2_ENC_FINISH_MODE_CONTINUE,
-  BCJ2_ENC_FINISH_MODE_END_BLOCK,
-  BCJ2_ENC_FINISH_MODE_END_STREAM
-} EBcj2Enc_FinishMode;
-
-typedef struct
-{
-  Byte *bufs[BCJ2_NUM_STREAMS];
-  const Byte *lims[BCJ2_NUM_STREAMS];
-  const Byte *src;
-  const Byte *srcLim;
-
-  unsigned state;
-  EBcj2Enc_FinishMode finishMode;
-
-  Byte prevByte;
-
-  Byte cache;
-  UInt32 range;
-  UInt64 low;
-  UInt64 cacheSize;
-
-  UInt32 ip;
-
-  /* 32-bit ralative offset in JUMP/CALL commands is
-       - (mod 4 GB)   in 32-bit mode
-       - signed Int32 in 64-bit mode
-     We use (mod 4 GB) check for fileSize.
-     Use fileSize up to 2 GB, if you want to support 32-bit and 64-bit code conversion. */
-  UInt32 fileIp;
-  UInt32 fileSize;    /* (fileSize <= ((UInt32)1 << 31)), 0 means no_limit */
-  UInt32 relatLimit;  /* (relatLimit <= ((UInt32)1 << 31)), 0 means desable_conversion */
-
-  UInt32 tempTarget;
-  unsigned tempPos;
-  Byte temp[4 * 2];
-
-  unsigned flushPos;
-  
-  UInt16 probs[2 + 256];
-} CBcj2Enc;
-
-void Bcj2Enc_Init(CBcj2Enc *p);
-void Bcj2Enc_Encode(CBcj2Enc *p);
-
-#define Bcj2Enc_Get_InputData_Size(p) ((SizeT)((p)->srcLim - (p)->src) + (p)->tempPos)
-#define Bcj2Enc_IsFinished(p) ((p)->flushPos == 5)
-
-
-#define BCJ2_RELAT_LIMIT_NUM_BITS 26
-#define BCJ2_RELAT_LIMIT ((UInt32)1 << BCJ2_RELAT_LIMIT_NUM_BITS)
-
-/* limit for CBcj2Enc::fileSize variable */
-#define BCJ2_FileSize_MAX ((UInt32)1 << 31)
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/Bcj2Enc.c

@@ -1,311 +0,0 @@
-/* Bcj2Enc.c -- BCJ2 Encoder (Converter for x86 code)
-2021-02-09 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-/* #define SHOW_STAT */
-
-#ifdef SHOW_STAT
-#include <stdio.h>
-#define PRF(x) x
-#else
-#define PRF(x)
-#endif
-
-#include <string.h>
-
-#include "Bcj2.h"
-#include "CpuArch.h"
-
-#define CProb UInt16
-
-#define kTopValue ((UInt32)1 << 24)
-#define kNumModelBits 11
-#define kBitModelTotal (1 << kNumModelBits)
-#define kNumMoveBits 5
-
-void Bcj2Enc_Init(CBcj2Enc *p)
-{
-  unsigned i;
-
-  p->state = BCJ2_ENC_STATE_OK;
-  p->finishMode = BCJ2_ENC_FINISH_MODE_CONTINUE;
-
-  p->prevByte = 0;
-
-  p->cache = 0;
-  p->range = 0xFFFFFFFF;
-  p->low = 0;
-  p->cacheSize = 1;
-
-  p->ip = 0;
-
-  p->fileIp = 0;
-  p->fileSize = 0;
-  p->relatLimit = BCJ2_RELAT_LIMIT;
-
-  p->tempPos = 0;
-
-  p->flushPos = 0;
-
-  for (i = 0; i < sizeof(p->probs) / sizeof(p->probs[0]); i++)
-    p->probs[i] = kBitModelTotal >> 1;
-}
-
-static BoolInt MY_FAST_CALL RangeEnc_ShiftLow(CBcj2Enc *p)
-{
-  if ((UInt32)p->low < (UInt32)0xFF000000 || (UInt32)(p->low >> 32) != 0)
-  {
-    Byte *buf = p->bufs[BCJ2_STREAM_RC];
-    do
-    {
-      if (buf == p->lims[BCJ2_STREAM_RC])
-      {
-        p->state = BCJ2_STREAM_RC;
-        p->bufs[BCJ2_STREAM_RC] = buf;
-        return True;
-      }
-      *buf++ = (Byte)(p->cache + (Byte)(p->low >> 32));
-      p->cache = 0xFF;
-    }
-    while (--p->cacheSize);
-    p->bufs[BCJ2_STREAM_RC] = buf;
-    p->cache = (Byte)((UInt32)p->low >> 24);
-  }
-  p->cacheSize++;
-  p->low = (UInt32)p->low << 8;
-  return False;
-}
-
-static void Bcj2Enc_Encode_2(CBcj2Enc *p)
-{
-  if (BCJ2_IS_32BIT_STREAM(p->state))
-  {
-    Byte *cur = p->bufs[p->state];
-    if (cur == p->lims[p->state])
-      return;
-    SetBe32(cur, p->tempTarget);
-    p->bufs[p->state] = cur + 4;
-  }
-
-  p->state = BCJ2_ENC_STATE_ORIG;
-
-  for (;;)
-  {
-    if (p->range < kTopValue)
-    {
-      if (RangeEnc_ShiftLow(p))
-        return;
-      p->range <<= 8;
-    }
-
-    {
-      {
-        const Byte *src = p->src;
-        const Byte *srcLim;
-        Byte *dest;
-        SizeT num = (SizeT)(p->srcLim - src);
-
-        if (p->finishMode == BCJ2_ENC_FINISH_MODE_CONTINUE)
-        {
-          if (num <= 4)
-            return;
-          num -= 4;
-        }
-        else if (num == 0)
-          break;
-
-        dest = p->bufs[BCJ2_STREAM_MAIN];
-        if (num > (SizeT)(p->lims[BCJ2_STREAM_MAIN] - dest))
-        {
-          num = (SizeT)(p->lims[BCJ2_STREAM_MAIN] - dest);
-          if (num == 0)
-          {
-            p->state = BCJ2_STREAM_MAIN;
-            return;
-          }
-        }
-       
-        srcLim = src + num;
-
-        if (p->prevByte == 0x0F && (src[0] & 0xF0) == 0x80)
-          *dest = src[0];
-        else for (;;)
-        {
-          Byte b = *src;
-          *dest = b;
-          if (b != 0x0F)
-          {
-            if ((b & 0xFE) == 0xE8)
-              break;
-            dest++;
-            if (++src != srcLim)
-              continue;
-            break;
-          }
-          dest++;
-          if (++src == srcLim)
-            break;
-          if ((*src & 0xF0) != 0x80)
-            continue;
-          *dest = *src;
-          break;
-        }
-        
-        num = (SizeT)(src - p->src);
-        
-        if (src == srcLim)
-        {
-          p->prevByte = src[-1];
-          p->bufs[BCJ2_STREAM_MAIN] = dest;
-          p->src = src;
-          p->ip += (UInt32)num;
-          continue;
-        }
- 
-        {
-          Byte context = (Byte)(num == 0 ? p->prevByte : src[-1]);
-          BoolInt needConvert;
-
-          p->bufs[BCJ2_STREAM_MAIN] = dest + 1;
-          p->ip += (UInt32)num + 1;
-          src++;
-          
-          needConvert = False;
-
-          if ((SizeT)(p->srcLim - src) >= 4)
-          {
-            UInt32 relatVal = GetUi32(src);
-            if ((p->fileSize == 0 || (UInt32)(p->ip + 4 + relatVal - p->fileIp) < p->fileSize)
-                && ((relatVal + p->relatLimit) >> 1) < p->relatLimit)
-              needConvert = True;
-          }
-
-          {
-            UInt32 bound;
-            unsigned ttt;
-            Byte b = src[-1];
-            CProb *prob = p->probs + (unsigned)(b == 0xE8 ? 2 + (unsigned)context : (b == 0xE9 ? 1 : 0));
-
-            ttt = *prob;
-            bound = (p->range >> kNumModelBits) * ttt;
-            
-            if (!needConvert)
-            {
-              p->range = bound;
-              *prob = (CProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));
-              p->src = src;
-              p->prevByte = b;
-              continue;
-            }
-            
-            p->low += bound;
-            p->range -= bound;
-            *prob = (CProb)(ttt - (ttt >> kNumMoveBits));
-
-            {
-              UInt32 relatVal = GetUi32(src);
-              UInt32 absVal;
-              p->ip += 4;
-              absVal = p->ip + relatVal;
-              p->prevByte = src[3];
-              src += 4;
-              p->src = src;
-              {
-                unsigned cj = (b == 0xE8) ? BCJ2_STREAM_CALL : BCJ2_STREAM_JUMP;
-                Byte *cur = p->bufs[cj];
-                if (cur == p->lims[cj])
-                {
-                  p->state = cj;
-                  p->tempTarget = absVal;
-                  return;
-                }
-                SetBe32(cur, absVal);
-                p->bufs[cj] = cur + 4;
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-
-  if (p->finishMode != BCJ2_ENC_FINISH_MODE_END_STREAM)
-    return;
-
-  for (; p->flushPos < 5; p->flushPos++)
-    if (RangeEnc_ShiftLow(p))
-      return;
-  p->state = BCJ2_ENC_STATE_OK;
-}
-
-
-void Bcj2Enc_Encode(CBcj2Enc *p)
-{
-  PRF(printf("\n"));
-  PRF(printf("---- ip = %8d   tempPos = %8d   src = %8d\n", p->ip, p->tempPos, p->srcLim - p->src));
-
-  if (p->tempPos != 0)
-  {
-    unsigned extra = 0;
-   
-    for (;;)
-    {
-      const Byte *src = p->src;
-      const Byte *srcLim = p->srcLim;
-      EBcj2Enc_FinishMode finishMode = p->finishMode;
-      
-      p->src = p->temp;
-      p->srcLim = p->temp + p->tempPos;
-      if (src != srcLim)
-        p->finishMode = BCJ2_ENC_FINISH_MODE_CONTINUE;
-      
-      PRF(printf("     ip = %8d   tempPos = %8d   src = %8d\n", p->ip, p->tempPos, p->srcLim - p->src));
-
-      Bcj2Enc_Encode_2(p);
-      
-      {
-        unsigned num = (unsigned)(p->src - p->temp);
-        unsigned tempPos = p->tempPos - num;
-        unsigned i;
-        p->tempPos = tempPos;
-        for (i = 0; i < tempPos; i++)
-          p->temp[i] = p->temp[(size_t)i + num];
-      
-        p->src = src;
-        p->srcLim = srcLim;
-        p->finishMode = finishMode;
-        
-        if (p->state != BCJ2_ENC_STATE_ORIG || src == srcLim)
-          return;
-        
-        if (extra >= tempPos)
-        {
-          p->src = src - tempPos;
-          p->tempPos = 0;
-          break;
-        }
-        
-        p->temp[tempPos] = src[0];
-        p->tempPos = tempPos + 1;
-        p->src = src + 1;
-        extra++;
-      }
-    }
-  }
-
-  PRF(printf("++++ ip = %8d   tempPos = %8d   src = %8d\n", p->ip, p->tempPos, p->srcLim - p->src));
-
-  Bcj2Enc_Encode_2(p);
-  
-  if (p->state == BCJ2_ENC_STATE_ORIG)
-  {
-    const Byte *src = p->src;
-    unsigned rem = (unsigned)(p->srcLim - src);
-    unsigned i;
-    for (i = 0; i < rem; i++)
-      p->temp[i] = src[i];
-    p->tempPos = rem;
-    p->src = src + rem;
-  }
-}

3rdparty/7z/src/Bra.c

@@ -1,230 +0,0 @@
-/* Bra.c -- Converters for RISC code
-2021-02-09 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "CpuArch.h"
-#include "Bra.h"
-
-SizeT ARM_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
-{
-  Byte *p;
-  const Byte *lim;
-  size &= ~(size_t)3;
-  ip += 4;
-  p = data;
-  lim = data + size;
-
-  if (encoding)
-
-  for (;;)
-  {
-    for (;;)
-    {
-      if (p >= lim)
-        return (SizeT)(p - data);
-      p += 4;
-      if (p[-1] == 0xEB)
-        break;
-    }
-    {
-      UInt32 v = GetUi32(p - 4);
-      v <<= 2;
-        v += ip + (UInt32)(p - data);
-      v >>= 2;
-      v &= 0x00FFFFFF;
-      v |= 0xEB000000;
-      SetUi32(p - 4, v);
-    }
-  }
-
-  for (;;)
-  {
-    for (;;)
-    {
-      if (p >= lim)
-        return (SizeT)(p - data);
-      p += 4;
-      if (p[-1] == 0xEB)
-        break;
-    }
-    {
-      UInt32 v = GetUi32(p - 4);
-      v <<= 2;
-        v -= ip + (UInt32)(p - data);
-      v >>= 2;
-      v &= 0x00FFFFFF;
-      v |= 0xEB000000;
-      SetUi32(p - 4, v);
-    }
-  }
-}
-
-
-SizeT ARMT_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
-{
-  Byte *p;
-  const Byte *lim;
-  size &= ~(size_t)1;
-  p = data;
-  lim = data + size - 4;
-
-  if (encoding)
-  
-  for (;;)
-  {
-    UInt32 b1;
-    for (;;)
-    {
-      UInt32 b3;
-      if (p > lim)
-        return (SizeT)(p - data);
-      b1 = p[1];
-      b3 = p[3];
-      p += 2;
-      b1 ^= 8;
-      if ((b3 & b1) >= 0xF8)
-        break;
-    }
-    {
-      UInt32 v =
-             ((UInt32)b1 << 19)
-          + (((UInt32)p[1] & 0x7) << 8)
-          + (((UInt32)p[-2] << 11))
-          + (p[0]);
-
-      p += 2;
-      {
-        UInt32 cur = (ip + (UInt32)(p - data)) >> 1;
-          v += cur;
-      }
-
-      p[-4] = (Byte)(v >> 11);
-      p[-3] = (Byte)(0xF0 | ((v >> 19) & 0x7));
-      p[-2] = (Byte)v;
-      p[-1] = (Byte)(0xF8 | (v >> 8));
-    }
-  }
-  
-  for (;;)
-  {
-    UInt32 b1;
-    for (;;)
-    {
-      UInt32 b3;
-      if (p > lim)
-        return (SizeT)(p - data);
-      b1 = p[1];
-      b3 = p[3];
-      p += 2;
-      b1 ^= 8;
-      if ((b3 & b1) >= 0xF8)
-        break;
-    }
-    {
-      UInt32 v =
-             ((UInt32)b1 << 19)
-          + (((UInt32)p[1] & 0x7) << 8)
-          + (((UInt32)p[-2] << 11))
-          + (p[0]);
-
-      p += 2;
-      {
-        UInt32 cur = (ip + (UInt32)(p - data)) >> 1;
-          v -= cur;
-      }
-
-      /*
-      SetUi16(p - 4, (UInt16)(((v >> 11) & 0x7FF) | 0xF000));
-      SetUi16(p - 2, (UInt16)(v | 0xF800));
-      */
-      
-      p[-4] = (Byte)(v >> 11);
-      p[-3] = (Byte)(0xF0 | ((v >> 19) & 0x7));
-      p[-2] = (Byte)v;
-      p[-1] = (Byte)(0xF8 | (v >> 8));
-    }
-  }
-}
-
-
-SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
-{
-  Byte *p;
-  const Byte *lim;
-  size &= ~(size_t)3;
-  ip -= 4;
-  p = data;
-  lim = data + size;
-
-  for (;;)
-  {
-    for (;;)
-    {
-      if (p >= lim)
-        return (SizeT)(p - data);
-      p += 4;
-      /* if ((v & 0xFC000003) == 0x48000001) */
-      if ((p[-4] & 0xFC) == 0x48 && (p[-1] & 3) == 1)
-        break;
-    }
-    {
-      UInt32 v = GetBe32(p - 4);
-      if (encoding)
-        v += ip + (UInt32)(p - data);
-      else
-        v -= ip + (UInt32)(p - data);
-      v &= 0x03FFFFFF;
-      v |= 0x48000000;
-      SetBe32(p - 4, v);
-    }
-  }
-}
-
-
-SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
-{
-  Byte *p;
-  const Byte *lim;
-  size &= ~(size_t)3;
-  ip -= 4;
-  p = data;
-  lim = data + size;
-
-  for (;;)
-  {
-    for (;;)
-    {
-      if (p >= lim)
-        return (SizeT)(p - data);
-      /*
-      v = GetBe32(p);
-      p += 4;
-      m = v + ((UInt32)5 << 29);
-      m ^= (UInt32)7 << 29;
-      m += (UInt32)1 << 22;
-      if ((m & ((UInt32)0x1FF << 23)) == 0)
-        break;
-      */
-      p += 4;
-      if ((p[-4] == 0x40 && (p[-3] & 0xC0) == 0) ||
-          (p[-4] == 0x7F && (p[-3] >= 0xC0)))
-        break;
-    }
-    {
-      UInt32 v = GetBe32(p - 4);
-      v <<= 2;
-      if (encoding)
-        v += ip + (UInt32)(p - data);
-      else
-        v -= ip + (UInt32)(p - data);
-      
-      v &= 0x01FFFFFF;
-      v -= (UInt32)1 << 24;
-      v ^= 0xFF000000;
-      v >>= 2;
-      v |= 0x40000000;
-      SetBe32(p - 4, v);
-    }
-  }
-}

3rdparty/7z/src/Bra.h

@@ -1,64 +0,0 @@
-/* Bra.h -- Branch converters for executables
-2013-01-18 : Igor Pavlov : Public domain */
-
-#ifndef __BRA_H
-#define __BRA_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-/*
-These functions convert relative addresses to absolute addresses
-in CALL instructions to increase the compression ratio.
-  
-  In:
-    data     - data buffer
-    size     - size of data
-    ip       - current virtual Instruction Pinter (IP) value
-    state    - state variable for x86 converter
-    encoding - 0 (for decoding), 1 (for encoding)
-  
-  Out:
-    state    - state variable for x86 converter
-
-  Returns:
-    The number of processed bytes. If you call these functions with multiple calls,
-    you must start next call with first byte after block of processed bytes.
-  
-  Type   Endian  Alignment  LookAhead
-  
-  x86    little      1          4
-  ARMT   little      2          2
-  ARM    little      4          0
-  PPC     big        4          0
-  SPARC   big        4          0
-  IA64   little     16          0
-
-  size must be >= Alignment + LookAhead, if it's not last block.
-  If (size < Alignment + LookAhead), converter returns 0.
-
-  Example:
-
-    UInt32 ip = 0;
-    for ()
-    {
-      ; size must be >= Alignment + LookAhead, if it's not last block
-      SizeT processed = Convert(data, size, ip, 1);
-      data += processed;
-      size -= processed;
-      ip += processed;
-    }
-*/
-
-#define x86_Convert_Init(state) { state = 0; }
-SizeT x86_Convert(Byte *data, SizeT size, UInt32 ip, UInt32 *state, int encoding);
-SizeT ARM_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
-SizeT ARMT_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
-SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
-SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
-SizeT IA64_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/Bra86.c

@@ -1,82 +0,0 @@
-/* Bra86.c -- Converter for x86 code (BCJ)
-2021-02-09 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "Bra.h"
-
-#define Test86MSByte(b) ((((b) + 1) & 0xFE) == 0)
-
-SizeT x86_Convert(Byte *data, SizeT size, UInt32 ip, UInt32 *state, int encoding)
-{
-  SizeT pos = 0;
-  UInt32 mask = *state & 7;
-  if (size < 5)
-    return 0;
-  size -= 4;
-  ip += 5;
-
-  for (;;)
-  {
-    Byte *p = data + pos;
-    const Byte *limit = data + size;
-    for (; p < limit; p++)
-      if ((*p & 0xFE) == 0xE8)
-        break;
-
-    {
-      SizeT d = (SizeT)(p - data) - pos;
-      pos = (SizeT)(p - data);
-      if (p >= limit)
-      {
-        *state = (d > 2 ? 0 : mask >> (unsigned)d);
-        return pos;
-      }
-      if (d > 2)
-        mask = 0;
-      else
-      {
-        mask >>= (unsigned)d;
-        if (mask != 0 && (mask > 4 || mask == 3 || Test86MSByte(p[(size_t)(mask >> 1) + 1])))
-        {
-          mask = (mask >> 1) | 4;
-          pos++;
-          continue;
-        }
-      }
-    }
-
-    if (Test86MSByte(p[4]))
-    {
-      UInt32 v = ((UInt32)p[4] << 24) | ((UInt32)p[3] << 16) | ((UInt32)p[2] << 8) | ((UInt32)p[1]);
-      UInt32 cur = ip + (UInt32)pos;
-      pos += 5;
-      if (encoding)
-        v += cur;
-      else
-        v -= cur;
-      if (mask != 0)
-      {
-        unsigned sh = (mask & 6) << 2;
-        if (Test86MSByte((Byte)(v >> sh)))
-        {
-          v ^= (((UInt32)0x100 << sh) - 1);
-          if (encoding)
-            v += cur;
-          else
-            v -= cur;
-        }
-        mask = 0;
-      }
-      p[1] = (Byte)v;
-      p[2] = (Byte)(v >> 8);
-      p[3] = (Byte)(v >> 16);
-      p[4] = (Byte)(0 - ((v >> 24) & 1));
-    }
-    else
-    {
-      mask = (mask >> 1) | 4;
-      pos++;
-    }
-  }
-}

3rdparty/7z/src/BraIA64.c

@@ -1,53 +0,0 @@
-/* BraIA64.c -- Converter for IA-64 code
-2017-01-26 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "CpuArch.h"
-#include "Bra.h"
-
-SizeT IA64_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
-{
-  SizeT i;
-  if (size < 16)
-    return 0;
-  size -= 16;
-  i = 0;
-  do
-  {
-    unsigned m = ((UInt32)0x334B0000 >> (data[i] & 0x1E)) & 3;
-    if (m)
-    {
-      m++;
-      do
-      {
-        Byte *p = data + (i + (size_t)m * 5 - 8);
-        if (((p[3] >> m) & 15) == 5
-            && (((p[-1] | ((UInt32)p[0] << 8)) >> m) & 0x70) == 0)
-        {
-          unsigned raw = GetUi32(p);
-          unsigned v = raw >> m;
-          v = (v & 0xFFFFF) | ((v & (1 << 23)) >> 3);
-          
-          v <<= 4;
-          if (encoding)
-            v += ip + (UInt32)i;
-          else
-            v -= ip + (UInt32)i;
-          v >>= 4;
-          
-          v &= 0x1FFFFF;
-          v += 0x700000;
-          v &= 0x8FFFFF;
-          raw &= ~((UInt32)0x8FFFFF << m);
-          raw |= (v << m);
-          SetUi32(p, raw);
-        }
-      }
-      while (++m <= 4);
-    }
-    i += 16;
-  }
-  while (i <= size);
-  return i;
-}

3rdparty/7z/src/Compiler.h

@@ -1,43 +0,0 @@
-/* Compiler.h
-2021-01-05 : Igor Pavlov : Public domain */
-
-#ifndef __7Z_COMPILER_H
-#define __7Z_COMPILER_H
-
-  #ifdef __clang__
-    #pragma clang diagnostic ignored "-Wunused-private-field"
-  #endif
-
-#ifdef _MSC_VER
-
-  #ifdef UNDER_CE
-    #define RPC_NO_WINDOWS_H
-    /* #pragma warning(disable : 4115) // '_RPC_ASYNC_STATE' : named type definition in parentheses */
-    #pragma warning(disable : 4201) // nonstandard extension used : nameless struct/union
-    #pragma warning(disable : 4214) // nonstandard extension used : bit field types other than int
-  #endif
-
-  #if _MSC_VER >= 1300
-    #pragma warning(disable : 4996) // This function or variable may be unsafe
-  #else
-    #pragma warning(disable : 4511) // copy constructor could not be generated
-    #pragma warning(disable : 4512) // assignment operator could not be generated
-    #pragma warning(disable : 4514) // unreferenced inline function has been removed
-    #pragma warning(disable : 4702) // unreachable code
-    #pragma warning(disable : 4710) // not inlined
-    #pragma warning(disable : 4714) // function marked as __forceinline not inlined
-    #pragma warning(disable : 4786) // identifier was truncated to '255' characters in the debug information
-  #endif
-
-  #ifdef __clang__
-    #pragma clang diagnostic ignored "-Wdeprecated-declarations"
-    #pragma clang diagnostic ignored "-Wmicrosoft-exception-spec"
-    // #pragma clang diagnostic ignored "-Wreserved-id-macro"
-  #endif
-
-#endif
-
-#define UNUSED_VAR(x) (void)x;
-/* #define UNUSED_VAR(x) x=x; */
-
-#endif

3rdparty/7z/src/CpuArch.c

@@ -1,478 +0,0 @@
-/* CpuArch.c -- CPU specific code
-2021-07-13 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "CpuArch.h"
-
-#ifdef MY_CPU_X86_OR_AMD64
-
-#if (defined(_MSC_VER) && !defined(MY_CPU_AMD64)) || defined(__GNUC__)
-#define USE_ASM
-#endif
-
-#if !defined(USE_ASM) && _MSC_VER >= 1500
-#include <intrin.h>
-#endif
-
-#if defined(USE_ASM) && !defined(MY_CPU_AMD64)
-static UInt32 CheckFlag(UInt32 flag)
-{
-  #ifdef _MSC_VER
-  __asm pushfd;
-  __asm pop EAX;
-  __asm mov EDX, EAX;
-  __asm xor EAX, flag;
-  __asm push EAX;
-  __asm popfd;
-  __asm pushfd;
-  __asm pop EAX;
-  __asm xor EAX, EDX;
-  __asm push EDX;
-  __asm popfd;
-  __asm and flag, EAX;
-  #else
-  __asm__ __volatile__ (
-    "pushf\n\t"
-    "pop  %%EAX\n\t"
-    "movl %%EAX,%%EDX\n\t"
-    "xorl %0,%%EAX\n\t"
-    "push %%EAX\n\t"
-    "popf\n\t"
-    "pushf\n\t"
-    "pop  %%EAX\n\t"
-    "xorl %%EDX,%%EAX\n\t"
-    "push %%EDX\n\t"
-    "popf\n\t"
-    "andl %%EAX, %0\n\t":
-    "=c" (flag) : "c" (flag) :
-    "%eax", "%edx");
-  #endif
-  return flag;
-}
-#define CHECK_CPUID_IS_SUPPORTED if (CheckFlag(1 << 18) == 0 || CheckFlag(1 << 21) == 0) return False;
-#else
-#define CHECK_CPUID_IS_SUPPORTED
-#endif
-
-#ifndef USE_ASM
-  #ifdef _MSC_VER
-    #if _MSC_VER >= 1600
-      #define MY__cpuidex  __cpuidex
-    #else
-
-/*
- __cpuid (function == 4) requires subfunction number in ECX.
-  MSDN: The __cpuid intrinsic clears the ECX register before calling the cpuid instruction.
-   __cpuid() in new MSVC clears ECX.
-   __cpuid() in old MSVC (14.00) doesn't clear ECX
- We still can use __cpuid for low (function) values that don't require ECX,
- but __cpuid() in old MSVC will be incorrect for some function values: (function == 4).
- So here we use the hack for old MSVC to send (subFunction) in ECX register to cpuid instruction,
- where ECX value is first parameter for FAST_CALL / NO_INLINE function,
- So the caller of MY__cpuidex_HACK() sets ECX as subFunction, and
- old MSVC for __cpuid() doesn't change ECX and cpuid instruction gets (subFunction) value.
- 
- DON'T remove MY_NO_INLINE and MY_FAST_CALL for MY__cpuidex_HACK() !!!
-*/
-
-static
-MY_NO_INLINE
-void MY_FAST_CALL MY__cpuidex_HACK(UInt32 subFunction, int *CPUInfo, UInt32 function)
-{
-  UNUSED_VAR(subFunction);
-  __cpuid(CPUInfo, function);
-}
-
-      #define MY__cpuidex(info, func, func2)  MY__cpuidex_HACK(func2, info, func)
-      #pragma message("======== MY__cpuidex_HACK WAS USED ========")
-    #endif
-  #else
-     #define MY__cpuidex(info, func, func2)  __cpuid(info, func)
-     #pragma message("======== (INCORRECT ?) cpuid WAS USED ========")
-  #endif
-#endif
-
-
-
-
-void MyCPUID(UInt32 function, UInt32 *a, UInt32 *b, UInt32 *c, UInt32 *d)
-{
-  #ifdef USE_ASM
-
-  #ifdef _MSC_VER
-
-  UInt32 a2, b2, c2, d2;
-  __asm xor EBX, EBX;
-  __asm xor ECX, ECX;
-  __asm xor EDX, EDX;
-  __asm mov EAX, function;
-  __asm cpuid;
-  __asm mov a2, EAX;
-  __asm mov b2, EBX;
-  __asm mov c2, ECX;
-  __asm mov d2, EDX;
-
-  *a = a2;
-  *b = b2;
-  *c = c2;
-  *d = d2;
-
-  #else
-
-  __asm__ __volatile__ (
-  #if defined(MY_CPU_AMD64) && defined(__PIC__)
-    "mov %%rbx, %%rdi;"
-    "cpuid;"
-    "xchg %%rbx, %%rdi;"
-    : "=a" (*a) ,
-      "=D" (*b) ,
-  #elif defined(MY_CPU_X86) && defined(__PIC__)
-    "mov %%ebx, %%edi;"
-    "cpuid;"
-    "xchgl %%ebx, %%edi;"
-    : "=a" (*a) ,
-      "=D" (*b) ,
-  #else
-    "cpuid"
-    : "=a" (*a) ,
-      "=b" (*b) ,
-  #endif
-      "=c" (*c) ,
-      "=d" (*d)
-    : "0" (function), "c"(0) ) ;
-
-  #endif
-  
-  #else
-
-  int CPUInfo[4];
-
-  MY__cpuidex(CPUInfo, (int)function, 0);
-
-  *a = (UInt32)CPUInfo[0];
-  *b = (UInt32)CPUInfo[1];
-  *c = (UInt32)CPUInfo[2];
-  *d = (UInt32)CPUInfo[3];
-
-  #endif
-}
-
-BoolInt x86cpuid_CheckAndRead(Cx86cpuid *p)
-{
-  CHECK_CPUID_IS_SUPPORTED
-  MyCPUID(0, &p->maxFunc, &p->vendor[0], &p->vendor[2], &p->vendor[1]);
-  MyCPUID(1, &p->ver, &p->b, &p->c, &p->d);
-  return True;
-}
-
-static const UInt32 kVendors[][3] =
-{
-  { 0x756E6547, 0x49656E69, 0x6C65746E},
-  { 0x68747541, 0x69746E65, 0x444D4163},
-  { 0x746E6543, 0x48727561, 0x736C7561}
-};
-
-int x86cpuid_GetFirm(const Cx86cpuid *p)
-{
-  unsigned i;
-  for (i = 0; i < sizeof(kVendors) / sizeof(kVendors[i]); i++)
-  {
-    const UInt32 *v = kVendors[i];
-    if (v[0] == p->vendor[0] &&
-        v[1] == p->vendor[1] &&
-        v[2] == p->vendor[2])
-      return (int)i;
-  }
-  return -1;
-}
-
-BoolInt CPU_Is_InOrder()
-{
-  Cx86cpuid p;
-  int firm;
-  UInt32 family, model;
-  if (!x86cpuid_CheckAndRead(&p))
-    return True;
-
-  family = x86cpuid_GetFamily(p.ver);
-  model = x86cpuid_GetModel(p.ver);
-  
-  firm = x86cpuid_GetFirm(&p);
-
-  switch (firm)
-  {
-    case CPU_FIRM_INTEL: return (family < 6 || (family == 6 && (
-        /* In-Order Atom CPU */
-           model == 0x1C  /* 45 nm, N4xx, D4xx, N5xx, D5xx, 230, 330 */
-        || model == 0x26  /* 45 nm, Z6xx */
-        || model == 0x27  /* 32 nm, Z2460 */
-        || model == 0x35  /* 32 nm, Z2760 */
-        || model == 0x36  /* 32 nm, N2xxx, D2xxx */
-        )));
-    case CPU_FIRM_AMD: return (family < 5 || (family == 5 && (model < 6 || model == 0xA)));
-    case CPU_FIRM_VIA: return (family < 6 || (family == 6 && model < 0xF));
-  }
-  return True;
-}
-
-#if !defined(MY_CPU_AMD64) && defined(_WIN32)
-#include <Windows.h>
-static BoolInt CPU_Sys_Is_SSE_Supported()
-{
-  OSVERSIONINFO vi;
-  vi.dwOSVersionInfoSize = sizeof(vi);
-  if (!GetVersionEx(&vi))
-    return False;
-  return (vi.dwMajorVersion >= 5);
-}
-#define CHECK_SYS_SSE_SUPPORT if (!CPU_Sys_Is_SSE_Supported()) return False;
-#else
-#define CHECK_SYS_SSE_SUPPORT
-#endif
-
-
-static UInt32 X86_CPUID_ECX_Get_Flags()
-{
-  Cx86cpuid p;
-  CHECK_SYS_SSE_SUPPORT
-  if (!x86cpuid_CheckAndRead(&p))
-    return 0;
-  return p.c;
-}
-
-BoolInt CPU_IsSupported_AES()
-{
-  return (X86_CPUID_ECX_Get_Flags() >> 25) & 1;
-}
-
-BoolInt CPU_IsSupported_SSSE3()
-{
-  return (X86_CPUID_ECX_Get_Flags() >> 9) & 1;
-}
-
-BoolInt CPU_IsSupported_SSE41()
-{
-  return (X86_CPUID_ECX_Get_Flags() >> 19) & 1;
-}
-
-BoolInt CPU_IsSupported_SHA()
-{
-  Cx86cpuid p;
-  CHECK_SYS_SSE_SUPPORT
-  if (!x86cpuid_CheckAndRead(&p))
-    return False;
-
-  if (p.maxFunc < 7)
-    return False;
-  {
-    UInt32 d[4] = { 0 };
-    MyCPUID(7, &d[0], &d[1], &d[2], &d[3]);
-    return (d[1] >> 29) & 1;
-  }
-}
-
-// #include <stdio.h>
-
-#ifdef _WIN32
-#include <Windows.h>
-#endif
-
-BoolInt CPU_IsSupported_AVX2()
-{
-  Cx86cpuid p;
-  CHECK_SYS_SSE_SUPPORT
-
-  #ifdef _WIN32
-  #define MY__PF_XSAVE_ENABLED  17
-  if (!IsProcessorFeaturePresent(MY__PF_XSAVE_ENABLED))
-    return False;
-  #endif
-
-  if (!x86cpuid_CheckAndRead(&p))
-    return False;
-  if (p.maxFunc < 7)
-    return False;
-  {
-    UInt32 d[4] = { 0 };
-    MyCPUID(7, &d[0], &d[1], &d[2], &d[3]);
-    // printf("\ncpuid(7): ebx=%8x ecx=%8x\n", d[1], d[2]);
-    return 1
-      & (d[1] >> 5); // avx2
-  }
-}
-
-BoolInt CPU_IsSupported_VAES_AVX2()
-{
-  Cx86cpuid p;
-  CHECK_SYS_SSE_SUPPORT
-
-  #ifdef _WIN32
-  #define MY__PF_XSAVE_ENABLED  17
-  if (!IsProcessorFeaturePresent(MY__PF_XSAVE_ENABLED))
-    return False;
-  #endif
-
-  if (!x86cpuid_CheckAndRead(&p))
-    return False;
-  if (p.maxFunc < 7)
-    return False;
-  {
-    UInt32 d[4] = { 0 };
-    MyCPUID(7, &d[0], &d[1], &d[2], &d[3]);
-    // printf("\ncpuid(7): ebx=%8x ecx=%8x\n", d[1], d[2]);
-    return 1
-      & (d[1] >> 5) // avx2
-      // & (d[1] >> 31) // avx512vl
-      & (d[2] >> 9); // vaes // VEX-256/EVEX
-  }
-}
-
-BoolInt CPU_IsSupported_PageGB()
-{
-  Cx86cpuid cpuid;
-  if (!x86cpuid_CheckAndRead(&cpuid))
-    return False;
-  {
-    UInt32 d[4] = { 0 };
-    MyCPUID(0x80000000, &d[0], &d[1], &d[2], &d[3]);
-    if (d[0] < 0x80000001)
-      return False;
-  }
-  {
-    UInt32 d[4] = { 0 };
-    MyCPUID(0x80000001, &d[0], &d[1], &d[2], &d[3]);
-    return (d[3] >> 26) & 1;
-  }
-}
-
-
-#elif defined(MY_CPU_ARM_OR_ARM64)
-
-#ifdef _WIN32
-
-#include <Windows.h>
-
-BoolInt CPU_IsSupported_CRC32()  { return IsProcessorFeaturePresent(PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE) ? 1 : 0; }
-BoolInt CPU_IsSupported_CRYPTO() { return IsProcessorFeaturePresent(PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE) ? 1 : 0; }
-BoolInt CPU_IsSupported_NEON()   { return IsProcessorFeaturePresent(PF_ARM_NEON_INSTRUCTIONS_AVAILABLE) ? 1 : 0; }
-
-#else
-
-#if defined(__APPLE__)
-
-/*
-#include <stdio.h>
-#include <string.h>
-static void Print_sysctlbyname(const char *name)
-{
-  size_t bufSize = 256;
-  char buf[256];
-  int res = sysctlbyname(name, &buf, &bufSize, NULL, 0);
-  {
-    int i;
-    printf("\nres = %d : %s : '%s' : bufSize = %d, numeric", res, name, buf, (unsigned)bufSize);
-    for (i = 0; i < 20; i++)
-      printf(" %2x", (unsigned)(Byte)buf[i]);
-
-  }
-}
-*/
-
-static BoolInt My_sysctlbyname_Get_BoolInt(const char *name)
-{
-  UInt32 val = 0;
-  if (My_sysctlbyname_Get_UInt32(name, &val) == 0 && val == 1)
-    return 1;
-  return 0;
-}
-
-  /*
-  Print_sysctlbyname("hw.pagesize");
-  Print_sysctlbyname("machdep.cpu.brand_string");
-  */
-
-BoolInt CPU_IsSupported_CRC32(void)
-{
-  return My_sysctlbyname_Get_BoolInt("hw.optional.armv8_crc32");
-}
-
-BoolInt CPU_IsSupported_NEON(void)
-{
-  return My_sysctlbyname_Get_BoolInt("hw.optional.neon");
-}
-
-#ifdef MY_CPU_ARM64
-#define APPLE_CRYPTO_SUPPORT_VAL 1
-#else
-#define APPLE_CRYPTO_SUPPORT_VAL 0
-#endif
-
-BoolInt CPU_IsSupported_SHA1(void) { return APPLE_CRYPTO_SUPPORT_VAL; }
-BoolInt CPU_IsSupported_SHA2(void) { return APPLE_CRYPTO_SUPPORT_VAL; }
-BoolInt CPU_IsSupported_AES (void) { return APPLE_CRYPTO_SUPPORT_VAL; }
-
-
-#else // __APPLE__
-
-#include <sys/auxv.h>
-
-#define USE_HWCAP
-
-#ifdef USE_HWCAP
-
-#include <asm/hwcap.h>
-
-  #define MY_HWCAP_CHECK_FUNC_2(name1, name2) \
-  BoolInt CPU_IsSupported_ ## name1() { return (getauxval(AT_HWCAP)  & (HWCAP_  ## name2)) ? 1 : 0; }
-
-#ifdef MY_CPU_ARM64
-  #define MY_HWCAP_CHECK_FUNC(name) \
-  MY_HWCAP_CHECK_FUNC_2(name, name)
-  MY_HWCAP_CHECK_FUNC_2(NEON, ASIMD)
-// MY_HWCAP_CHECK_FUNC (ASIMD)
-#elif defined(MY_CPU_ARM)
-  #define MY_HWCAP_CHECK_FUNC(name) \
-  BoolInt CPU_IsSupported_ ## name() { return (getauxval(AT_HWCAP2) & (HWCAP2_ ## name)) ? 1 : 0; }
-  MY_HWCAP_CHECK_FUNC_2(NEON, NEON)
-#endif
-
-#else // USE_HWCAP
-
-  #define MY_HWCAP_CHECK_FUNC(name) \
-  BoolInt CPU_IsSupported_ ## name() { return 0; }
-  MY_HWCAP_CHECK_FUNC(NEON)
-
-#endif // USE_HWCAP
-
-MY_HWCAP_CHECK_FUNC (CRC32)
-MY_HWCAP_CHECK_FUNC (SHA1)
-MY_HWCAP_CHECK_FUNC (SHA2)
-MY_HWCAP_CHECK_FUNC (AES)
-
-#endif // __APPLE__
-#endif // _WIN32
-
-#endif // MY_CPU_ARM_OR_ARM64
-
-
-
-#ifdef __APPLE__
-
-#include <sys/sysctl.h>
-
-int My_sysctlbyname_Get(const char *name, void *buf, size_t *bufSize)
-{
-  return sysctlbyname(name, buf, bufSize, NULL, 0);
-}
-
-int My_sysctlbyname_Get_UInt32(const char *name, UInt32 *val)
-{
-  size_t bufSize = sizeof(*val);
-  int res = My_sysctlbyname_Get(name, val, &bufSize);
-  if (res == 0 && bufSize != sizeof(*val))
-    return EFAULT;
-  return res;
-}
-
-#endif

3rdparty/7z/src/CpuArch.h

@@ -1,445 +0,0 @@
-/* CpuArch.h -- CPU specific code
-2022-07-15 : Igor Pavlov : Public domain */
-
-#ifndef __CPU_ARCH_H
-#define __CPU_ARCH_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-/*
-MY_CPU_LE means that CPU is LITTLE ENDIAN.
-MY_CPU_BE means that CPU is BIG ENDIAN.
-If MY_CPU_LE and MY_CPU_BE are not defined, we don't know about ENDIANNESS of platform.
-
-MY_CPU_LE_UNALIGN means that CPU is LITTLE ENDIAN and CPU supports unaligned memory accesses.
-
-MY_CPU_64BIT means that processor can work with 64-bit registers.
-  MY_CPU_64BIT can be used to select fast code branch
-  MY_CPU_64BIT doesn't mean that (sizeof(void *) == 8)
-*/
-
-#if  defined(_M_X64) \
-  || defined(_M_AMD64) \
-  || defined(__x86_64__) \
-  || defined(__AMD64__) \
-  || defined(__amd64__)
-  #define MY_CPU_AMD64
-  #ifdef __ILP32__
-    #define MY_CPU_NAME "x32"
-    #define MY_CPU_SIZEOF_POINTER 4
-  #else
-    #define MY_CPU_NAME "x64"
-    #define MY_CPU_SIZEOF_POINTER 8
-  #endif
-  #define MY_CPU_64BIT
-#endif
-
-
-#if  defined(_M_IX86) \
-  || defined(__i386__)
-  #define MY_CPU_X86
-  #define MY_CPU_NAME "x86"
-  /* #define MY_CPU_32BIT */
-  #define MY_CPU_SIZEOF_POINTER 4
-#endif
-
-
-#if  defined(_M_ARM64) \
-  || defined(__AARCH64EL__) \
-  || defined(__AARCH64EB__) \
-  || defined(__aarch64__)
-  #define MY_CPU_ARM64
-  #define MY_CPU_NAME "arm64"
-  #define MY_CPU_64BIT
-#endif
-
-
-#if  defined(_M_ARM) \
-  || defined(_M_ARM_NT) \
-  || defined(_M_ARMT) \
-  || defined(__arm__) \
-  || defined(__thumb__) \
-  || defined(__ARMEL__) \
-  || defined(__ARMEB__) \
-  || defined(__THUMBEL__) \
-  || defined(__THUMBEB__)
-  #define MY_CPU_ARM
-
-  #if defined(__thumb__) || defined(__THUMBEL__) || defined(_M_ARMT)
-    #define MY_CPU_NAME "armt"
-  #else
-    #define MY_CPU_NAME "arm"
-  #endif
-  /* #define MY_CPU_32BIT */
-  #define MY_CPU_SIZEOF_POINTER 4
-#endif
-
-
-#if  defined(_M_IA64) \
-  || defined(__ia64__)
-  #define MY_CPU_IA64
-  #define MY_CPU_NAME "ia64"
-  #define MY_CPU_64BIT
-#endif
-
-
-#if  defined(__mips64) \
-  || defined(__mips64__) \
-  || (defined(__mips) && (__mips == 64 || __mips == 4 || __mips == 3))
-  #define MY_CPU_NAME "mips64"
-  #define MY_CPU_64BIT
-#elif defined(__mips__)
-  #define MY_CPU_NAME "mips"
-  /* #define MY_CPU_32BIT */
-#endif
-
-
-#if  defined(__ppc64__) \
-  || defined(__powerpc64__) \
-  || defined(__ppc__) \
-  || defined(__powerpc__) \
-  || defined(__PPC__) \
-  || defined(_POWER)
-
-#if  defined(__ppc64__) \
-  || defined(__powerpc64__) \
-  || defined(_LP64) \
-  || defined(__64BIT__)
-  #ifdef __ILP32__
-    #define MY_CPU_NAME "ppc64-32"
-    #define MY_CPU_SIZEOF_POINTER 4
-  #else
-    #define MY_CPU_NAME "ppc64"
-    #define MY_CPU_SIZEOF_POINTER 8
-  #endif
-  #define MY_CPU_64BIT
-#else
-  #define MY_CPU_NAME "ppc"
-  #define MY_CPU_SIZEOF_POINTER 4
-  /* #define MY_CPU_32BIT */
-#endif
-#endif
-
-
-#if  defined(__riscv) \
-  || defined(__riscv__)
-  #if __riscv_xlen == 32
-    #define MY_CPU_NAME "riscv32"
-  #elif __riscv_xlen == 64
-    #define MY_CPU_NAME "riscv64"
-  #else
-    #define MY_CPU_NAME "riscv"
-  #endif
-#endif
-
-
-#if defined(MY_CPU_X86) || defined(MY_CPU_AMD64)
-#define MY_CPU_X86_OR_AMD64
-#endif
-
-#if defined(MY_CPU_ARM) || defined(MY_CPU_ARM64)
-#define MY_CPU_ARM_OR_ARM64
-#endif
-
-
-#ifdef _WIN32
-
-  #ifdef MY_CPU_ARM
-  #define MY_CPU_ARM_LE
-  #endif
-
-  #ifdef MY_CPU_ARM64
-  #define MY_CPU_ARM64_LE
-  #endif
-
-  #ifdef _M_IA64
-  #define MY_CPU_IA64_LE
-  #endif
-
-#endif
-
-
-#if defined(MY_CPU_X86_OR_AMD64) \
-    || defined(MY_CPU_ARM_LE) \
-    || defined(MY_CPU_ARM64_LE) \
-    || defined(MY_CPU_IA64_LE) \
-    || defined(__LITTLE_ENDIAN__) \
-    || defined(__ARMEL__) \
-    || defined(__THUMBEL__) \
-    || defined(__AARCH64EL__) \
-    || defined(__MIPSEL__) \
-    || defined(__MIPSEL) \
-    || defined(_MIPSEL) \
-    || defined(__BFIN__) \
-    || (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
-  #define MY_CPU_LE
-#endif
-
-#if defined(__BIG_ENDIAN__) \
-    || defined(__ARMEB__) \
-    || defined(__THUMBEB__) \
-    || defined(__AARCH64EB__) \
-    || defined(__MIPSEB__) \
-    || defined(__MIPSEB) \
-    || defined(_MIPSEB) \
-    || defined(__m68k__) \
-    || defined(__s390__) \
-    || defined(__s390x__) \
-    || defined(__zarch__) \
-    || (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
-  #define MY_CPU_BE
-#endif
-
-
-#if defined(MY_CPU_LE) && defined(MY_CPU_BE)
-  #error Stop_Compiling_Bad_Endian
-#endif
-
-
-#if defined(MY_CPU_32BIT) && defined(MY_CPU_64BIT)
-  #error Stop_Compiling_Bad_32_64_BIT
-#endif
-
-#ifdef __SIZEOF_POINTER__
-  #ifdef MY_CPU_SIZEOF_POINTER
-    #if MY_CPU_SIZEOF_POINTER != __SIZEOF_POINTER__
-      #error Stop_Compiling_Bad_MY_CPU_PTR_SIZE
-    #endif
-  #else
-    #define MY_CPU_SIZEOF_POINTER  __SIZEOF_POINTER__
-  #endif
-#endif
-
-#if defined(MY_CPU_SIZEOF_POINTER) && (MY_CPU_SIZEOF_POINTER == 4)
-#if defined (_LP64)
-      #error Stop_Compiling_Bad_MY_CPU_PTR_SIZE
-#endif
-#endif
-
-#ifdef _MSC_VER
-  #if _MSC_VER >= 1300
-    #define MY_CPU_pragma_pack_push_1   __pragma(pack(push, 1))
-    #define MY_CPU_pragma_pop           __pragma(pack(pop))
-  #else
-    #define MY_CPU_pragma_pack_push_1
-    #define MY_CPU_pragma_pop
-  #endif
-#else
-  #ifdef __xlC__
-    #define MY_CPU_pragma_pack_push_1   _Pragma("pack(1)")
-    #define MY_CPU_pragma_pop           _Pragma("pack()")
-  #else
-    #define MY_CPU_pragma_pack_push_1   _Pragma("pack(push, 1)")
-    #define MY_CPU_pragma_pop           _Pragma("pack(pop)")
-  #endif
-#endif
-
-
-#ifndef MY_CPU_NAME
-  #ifdef MY_CPU_LE
-    #define MY_CPU_NAME "LE"
-  #elif defined(MY_CPU_BE)
-    #define MY_CPU_NAME "BE"
-  #else
-    /*
-    #define MY_CPU_NAME ""
-    */
-  #endif
-#endif
-
-
-
-
-
-#ifdef MY_CPU_LE
-  #if defined(MY_CPU_X86_OR_AMD64) \
-      || defined(MY_CPU_ARM64)
-    #define MY_CPU_LE_UNALIGN
-    #define MY_CPU_LE_UNALIGN_64
-  #elif defined(__ARM_FEATURE_UNALIGNED)
-    /* gcc9 for 32-bit arm can use LDRD instruction that requires 32-bit alignment.
-       So we can't use unaligned 64-bit operations. */
-    #define MY_CPU_LE_UNALIGN
-  #endif
-#endif
-
-
-#ifdef MY_CPU_LE_UNALIGN
-
-#define GetUi16(p) (*(const UInt16 *)(const void *)(p))
-#define GetUi32(p) (*(const UInt32 *)(const void *)(p))
-#ifdef MY_CPU_LE_UNALIGN_64
-#define GetUi64(p) (*(const UInt64 *)(const void *)(p))
-#endif
-
-#define SetUi16(p, v) { *(UInt16 *)(void *)(p) = (v); }
-#define SetUi32(p, v) { *(UInt32 *)(void *)(p) = (v); }
-#ifdef MY_CPU_LE_UNALIGN_64
-#define SetUi64(p, v) { *(UInt64 *)(void *)(p) = (v); }
-#endif
-
-#else
-
-#define GetUi16(p) ( (UInt16) ( \
-             ((const Byte *)(p))[0] | \
-    ((UInt16)((const Byte *)(p))[1] << 8) ))
-
-#define GetUi32(p) ( \
-             ((const Byte *)(p))[0]        | \
-    ((UInt32)((const Byte *)(p))[1] <<  8) | \
-    ((UInt32)((const Byte *)(p))[2] << 16) | \
-    ((UInt32)((const Byte *)(p))[3] << 24))
-
-#define SetUi16(p, v) { Byte *_ppp_ = (Byte *)(p); UInt32 _vvv_ = (v); \
-    _ppp_[0] = (Byte)_vvv_; \
-    _ppp_[1] = (Byte)(_vvv_ >> 8); }
-
-#define SetUi32(p, v) { Byte *_ppp_ = (Byte *)(p); UInt32 _vvv_ = (v); \
-    _ppp_[0] = (Byte)_vvv_; \
-    _ppp_[1] = (Byte)(_vvv_ >> 8); \
-    _ppp_[2] = (Byte)(_vvv_ >> 16); \
-    _ppp_[3] = (Byte)(_vvv_ >> 24); }
-
-#endif
-
-
-#ifndef MY_CPU_LE_UNALIGN_64
-
-#define GetUi64(p) (GetUi32(p) | ((UInt64)GetUi32(((const Byte *)(p)) + 4) << 32))
-
-#define SetUi64(p, v) { Byte *_ppp2_ = (Byte *)(p); UInt64 _vvv2_ = (v); \
-    SetUi32(_ppp2_    , (UInt32)_vvv2_); \
-    SetUi32(_ppp2_ + 4, (UInt32)(_vvv2_ >> 32)); }
-
-#endif
-
-
-
-
-#ifdef __has_builtin
-  #define MY__has_builtin(x) __has_builtin(x)
-#else
-  #define MY__has_builtin(x) 0
-#endif
-
-#if defined(MY_CPU_LE_UNALIGN) && /* defined(_WIN64) && */ defined(_MSC_VER) && (_MSC_VER >= 1300)
-
-/* Note: we use bswap instruction, that is unsupported in 386 cpu */
-
-#include <stdlib.h>
-
-#pragma intrinsic(_byteswap_ushort)
-#pragma intrinsic(_byteswap_ulong)
-#pragma intrinsic(_byteswap_uint64)
-
-/* #define GetBe16(p) _byteswap_ushort(*(const UInt16 *)(const Byte *)(p)) */
-#define GetBe32(p) _byteswap_ulong (*(const UInt32 *)(const void *)(p))
-#define GetBe64(p) _byteswap_uint64(*(const UInt64 *)(const void *)(p))
-
-#define SetBe32(p, v) (*(UInt32 *)(void *)(p)) = _byteswap_ulong(v)
-
-#elif defined(MY_CPU_LE_UNALIGN) && ( \
-       (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))) \
-    || (defined(__clang__) && MY__has_builtin(__builtin_bswap16)) )
-
-/* #define GetBe16(p) __builtin_bswap16(*(const UInt16 *)(const void *)(p)) */
-#define GetBe32(p) __builtin_bswap32(*(const UInt32 *)(const void *)(p))
-#define GetBe64(p) __builtin_bswap64(*(const UInt64 *)(const void *)(p))
-
-#define SetBe32(p, v) (*(UInt32 *)(void *)(p)) = __builtin_bswap32(v)
-
-#else
-
-#define GetBe32(p) ( \
-    ((UInt32)((const Byte *)(p))[0] << 24) | \
-    ((UInt32)((const Byte *)(p))[1] << 16) | \
-    ((UInt32)((const Byte *)(p))[2] <<  8) | \
-             ((const Byte *)(p))[3] )
-
-#define GetBe64(p) (((UInt64)GetBe32(p) << 32) | GetBe32(((const Byte *)(p)) + 4))
-
-#define SetBe32(p, v) { Byte *_ppp_ = (Byte *)(p); UInt32 _vvv_ = (v); \
-    _ppp_[0] = (Byte)(_vvv_ >> 24); \
-    _ppp_[1] = (Byte)(_vvv_ >> 16); \
-    _ppp_[2] = (Byte)(_vvv_ >> 8); \
-    _ppp_[3] = (Byte)_vvv_; }
-
-#endif
-
-
-#ifndef GetBe16
-
-#define GetBe16(p) ( (UInt16) ( \
-    ((UInt16)((const Byte *)(p))[0] << 8) | \
-             ((const Byte *)(p))[1] ))
-
-#endif
-
-
-
-#ifdef MY_CPU_X86_OR_AMD64
-
-typedef struct
-{
-  UInt32 maxFunc;
-  UInt32 vendor[3];
-  UInt32 ver;
-  UInt32 b;
-  UInt32 c;
-  UInt32 d;
-} Cx86cpuid;
-
-enum
-{
-  CPU_FIRM_INTEL,
-  CPU_FIRM_AMD,
-  CPU_FIRM_VIA
-};
-
-void MyCPUID(UInt32 function, UInt32 *a, UInt32 *b, UInt32 *c, UInt32 *d);
-
-BoolInt x86cpuid_CheckAndRead(Cx86cpuid *p);
-int x86cpuid_GetFirm(const Cx86cpuid *p);
-
-#define x86cpuid_GetFamily(ver) (((ver >> 16) & 0xFF0) | ((ver >> 8) & 0xF))
-#define x86cpuid_GetModel(ver)  (((ver >> 12) &  0xF0) | ((ver >> 4) & 0xF))
-#define x86cpuid_GetStepping(ver) (ver & 0xF)
-
-BoolInt CPU_Is_InOrder(void);
-
-BoolInt CPU_IsSupported_AES(void);
-BoolInt CPU_IsSupported_AVX2(void);
-BoolInt CPU_IsSupported_VAES_AVX2(void);
-BoolInt CPU_IsSupported_SSSE3(void);
-BoolInt CPU_IsSupported_SSE41(void);
-BoolInt CPU_IsSupported_SHA(void);
-BoolInt CPU_IsSupported_PageGB(void);
-
-#elif defined(MY_CPU_ARM_OR_ARM64)
-
-BoolInt CPU_IsSupported_CRC32(void);
-BoolInt CPU_IsSupported_NEON(void);
-
-#if defined(_WIN32)
-BoolInt CPU_IsSupported_CRYPTO(void);
-#define CPU_IsSupported_SHA1  CPU_IsSupported_CRYPTO
-#define CPU_IsSupported_SHA2  CPU_IsSupported_CRYPTO
-#define CPU_IsSupported_AES   CPU_IsSupported_CRYPTO
-#else
-BoolInt CPU_IsSupported_SHA1(void);
-BoolInt CPU_IsSupported_SHA2(void);
-BoolInt CPU_IsSupported_AES(void);
-#endif
-
-#endif
-
-#if defined(__APPLE__)
-int My_sysctlbyname_Get(const char *name, void *buf, size_t *bufSize);
-int My_sysctlbyname_Get_UInt32(const char *name, UInt32 *val);
-#endif
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/Delta.c

@@ -1,169 +0,0 @@
-/* Delta.c -- Delta converter
-2021-02-09 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "Delta.h"
-
-void Delta_Init(Byte *state)
-{
-  unsigned i;
-  for (i = 0; i < DELTA_STATE_SIZE; i++)
-    state[i] = 0;
-}
-
-
-void Delta_Encode(Byte *state, unsigned delta, Byte *data, SizeT size)
-{
-  Byte temp[DELTA_STATE_SIZE];
-
-  if (size == 0)
-    return;
-
-  {
-    unsigned i = 0;
-    do
-      temp[i] = state[i];
-    while (++i != delta);
-  }
-
-  if (size <= delta)
-  {
-    unsigned i = 0, k;
-    do
-    {
-      Byte b = *data;
-      *data++ = (Byte)(b - temp[i]);
-      temp[i] = b;
-    }
-    while (++i != size);
-    
-    k = 0;
-    
-    do
-    {
-      if (i == delta)
-        i = 0;
-      state[k] = temp[i++];
-    }
-    while (++k != delta);
-    
-    return;
-  }
-    
-  {
-    Byte *p = data + size - delta;
-    {
-      unsigned i = 0;
-      do
-        state[i] = *p++;
-      while (++i != delta);
-    }
-    {
-      const Byte *lim = data + delta;
-      ptrdiff_t dif = -(ptrdiff_t)delta;
-      
-      if (((ptrdiff_t)size + dif) & 1)
-      {
-        --p;  *p = (Byte)(*p - p[dif]);
-      }
-
-      while (p != lim)
-      {
-        --p;  *p = (Byte)(*p - p[dif]);
-        --p;  *p = (Byte)(*p - p[dif]);
-      }
-      
-      dif = -dif;
-      
-      do
-      {
-        --p;  *p = (Byte)(*p - temp[--dif]);
-      }
-      while (dif != 0);
-    }
-  }
-}
-
-
-void Delta_Decode(Byte *state, unsigned delta, Byte *data, SizeT size)
-{
-  unsigned i;
-  const Byte *lim;
-
-  if (size == 0)
-    return;
-  
-  i = 0;
-  lim = data + size;
-  
-  if (size <= delta)
-  {
-    do
-      *data = (Byte)(*data + state[i++]);
-    while (++data != lim);
-
-    for (; delta != i; state++, delta--)
-      *state = state[i];
-    data -= i;
-  }
-  else
-  {
-    /*
-    #define B(n) b ## n
-    #define I(n) Byte B(n) = state[n];
-    #define U(n) { B(n) = (Byte)((B(n)) + *data++); data[-1] = (B(n)); }
-    #define F(n) if (data != lim) { U(n) }
-
-    if (delta == 1)
-    {
-      I(0)
-      if ((lim - data) & 1) { U(0) }
-      while (data != lim) { U(0) U(0) }
-      data -= 1;
-    }
-    else if (delta == 2)
-    {
-      I(0) I(1)
-      lim -= 1; while (data < lim) { U(0) U(1) }
-      lim += 1; F(0)
-      data -= 2;
-    }
-    else if (delta == 3)
-    {
-      I(0) I(1) I(2)
-      lim -= 2; while (data < lim) { U(0) U(1) U(2) }
-      lim += 2; F(0) F(1)
-      data -= 3;
-    }
-    else if (delta == 4)
-    {
-      I(0) I(1) I(2) I(3)
-      lim -= 3; while (data < lim) { U(0) U(1) U(2) U(3) }
-      lim += 3; F(0) F(1) F(2)
-      data -= 4;
-    }
-    else
-    */
-    {
-      do
-      {
-        *data = (Byte)(*data + state[i++]);
-        data++;
-      }
-      while (i != delta);
-  
-      {
-        ptrdiff_t dif = -(ptrdiff_t)delta;
-        do
-          *data = (Byte)(*data + data[dif]);
-        while (++data != lim);
-        data += dif;
-      }
-    }
-  }
-
-  do
-    *state++ = *data;
-  while (++data != lim);
-}

3rdparty/7z/src/Delta.h

@@ -1,19 +0,0 @@
-/* Delta.h -- Delta converter
-2013-01-18 : Igor Pavlov : Public domain */
-
-#ifndef __DELTA_H
-#define __DELTA_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-#define DELTA_STATE_SIZE 256
-
-void Delta_Init(Byte *state);
-void Delta_Encode(Byte *state, unsigned delta, Byte *data, SizeT size);
-void Delta_Decode(Byte *state, unsigned delta, Byte *data, SizeT size);
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/DllSecur.c

@@ -1,114 +0,0 @@
-/* DllSecur.c -- DLL loading security
-2022-07-15 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#ifdef _WIN32
-
-#include <Windows.h>
-
-#include "DllSecur.h"
-
-#ifndef UNDER_CE
-
-#if defined(__GNUC__) && (__GNUC__ >= 8)
-  #pragma GCC diagnostic ignored "-Wcast-function-type"
-#endif
-
-typedef BOOL (WINAPI *Func_SetDefaultDllDirectories)(DWORD DirectoryFlags);
-
-#define MY_LOAD_LIBRARY_SEARCH_USER_DIRS 0x400
-#define MY_LOAD_LIBRARY_SEARCH_SYSTEM32  0x800
-
-static const char * const g_Dlls =
-  #ifndef _CONSOLE
-  "UXTHEME\0"
-  #endif
-  "USERENV\0"
-  "SETUPAPI\0"
-  "APPHELP\0"
-  "PROPSYS\0"
-  "DWMAPI\0"
-  "CRYPTBASE\0"
-  "OLEACC\0"
-  "CLBCATQ\0"
-  "VERSION\0"
-  ;
-
-#endif
-
-// #define MY_CAST_FUNC  (void(*)())
-#define MY_CAST_FUNC
-
-void My_SetDefaultDllDirectories()
-{
-  #ifndef UNDER_CE
-  
-    OSVERSIONINFO vi;
-    vi.dwOSVersionInfoSize = sizeof(vi);
-    if (!GetVersionEx(&vi) || vi.dwMajorVersion != 6 || vi.dwMinorVersion != 0)
-    {
-      Func_SetDefaultDllDirectories setDllDirs = (Func_SetDefaultDllDirectories)
-          MY_CAST_FUNC GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "SetDefaultDllDirectories");
-      if (setDllDirs)
-        if (setDllDirs(MY_LOAD_LIBRARY_SEARCH_SYSTEM32 | MY_LOAD_LIBRARY_SEARCH_USER_DIRS))
-          return;
-    }
-
-  #endif
-}
-
-
-void LoadSecurityDlls()
-{
-  #ifndef UNDER_CE
-  
-  wchar_t buf[MAX_PATH + 100];
-
-  {
-    // at Vista (ver 6.0) : CoCreateInstance(CLSID_ShellLink, ...) doesn't work after SetDefaultDllDirectories() : Check it ???
-    OSVERSIONINFO vi;
-    vi.dwOSVersionInfoSize = sizeof(vi);
-    if (!GetVersionEx(&vi) || vi.dwMajorVersion != 6 || vi.dwMinorVersion != 0)
-    {
-      Func_SetDefaultDllDirectories setDllDirs = (Func_SetDefaultDllDirectories)
-          MY_CAST_FUNC GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "SetDefaultDllDirectories");
-      if (setDllDirs)
-        if (setDllDirs(MY_LOAD_LIBRARY_SEARCH_SYSTEM32 | MY_LOAD_LIBRARY_SEARCH_USER_DIRS))
-          return;
-    }
-  }
-
-  {
-    unsigned len = GetSystemDirectoryW(buf, MAX_PATH + 2);
-    if (len == 0 || len > MAX_PATH)
-      return;
-  }
-  {
-    const char *dll;
-    unsigned pos = (unsigned)lstrlenW(buf);
-
-    if (buf[pos - 1] != '\\')
-      buf[pos++] = '\\';
-    
-    for (dll = g_Dlls; dll[0] != 0;)
-    {
-      unsigned k = 0;
-      for (;;)
-      {
-        char c = *dll++;
-        buf[pos + k] = (Byte)c;
-        k++;
-        if (c == 0)
-          break;
-      }
-
-      lstrcatW(buf, L".dll");
-      LoadLibraryExW(buf, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
-    }
-  }
-  
-  #endif
-}
-
-#endif

3rdparty/7z/src/DllSecur.h

@@ -1,20 +0,0 @@
-/* DllSecur.h -- DLL loading for security
-2018-02-19 : Igor Pavlov : Public domain */
-
-#ifndef __DLL_SECUR_H
-#define __DLL_SECUR_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-#ifdef _WIN32
-
-void My_SetDefaultDllDirectories(void);
-void LoadSecurityDlls(void);
-
-#endif
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/LzFind.h

@@ -1,136 +0,0 @@
-/* LzFind.h -- Match finder for LZ algorithms
-2021-07-13 : Igor Pavlov : Public domain */
-
-#ifndef __LZ_FIND_H
-#define __LZ_FIND_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-typedef UInt32 CLzRef;
-
-typedef struct _CMatchFinder
-{
-  Byte *buffer;
-  UInt32 pos;
-  UInt32 posLimit;
-  UInt32 streamPos;  /* wrap over Zero is allowed (streamPos < pos). Use (UInt32)(streamPos - pos) */
-  UInt32 lenLimit;
-
-  UInt32 cyclicBufferPos;
-  UInt32 cyclicBufferSize; /* it must be = (historySize + 1) */
-
-  Byte streamEndWasReached;
-  Byte btMode;
-  Byte bigHash;
-  Byte directInput;
-
-  UInt32 matchMaxLen;
-  CLzRef *hash;
-  CLzRef *son;
-  UInt32 hashMask;
-  UInt32 cutValue;
-
-  Byte *bufferBase;
-  ISeqInStream *stream;
-  
-  UInt32 blockSize;
-  UInt32 keepSizeBefore;
-  UInt32 keepSizeAfter;
-
-  UInt32 numHashBytes;
-  size_t directInputRem;
-  UInt32 historySize;
-  UInt32 fixedHashSize;
-  UInt32 hashSizeSum;
-  SRes result;
-  UInt32 crc[256];
-  size_t numRefs;
-
-  UInt64 expectedDataSize;
-} CMatchFinder;
-
-#define Inline_MatchFinder_GetPointerToCurrentPos(p) ((const Byte *)(p)->buffer)
-
-#define Inline_MatchFinder_GetNumAvailableBytes(p) ((UInt32)((p)->streamPos - (p)->pos))
-
-/*
-#define Inline_MatchFinder_IsFinishedOK(p) \
-    ((p)->streamEndWasReached \
-        && (p)->streamPos == (p)->pos \
-        && (!(p)->directInput || (p)->directInputRem == 0))
-*/
-      
-int MatchFinder_NeedMove(CMatchFinder *p);
-/* Byte *MatchFinder_GetPointerToCurrentPos(CMatchFinder *p); */
-void MatchFinder_MoveBlock(CMatchFinder *p);
-void MatchFinder_ReadIfRequired(CMatchFinder *p);
-
-void MatchFinder_Construct(CMatchFinder *p);
-
-/* Conditions:
-     historySize <= 3 GB
-     keepAddBufferBefore + matchMaxLen + keepAddBufferAfter < 511MB
-*/
-int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
-    UInt32 keepAddBufferBefore, UInt32 matchMaxLen, UInt32 keepAddBufferAfter,
-    ISzAllocPtr alloc);
-void MatchFinder_Free(CMatchFinder *p, ISzAllocPtr alloc);
-void MatchFinder_Normalize3(UInt32 subValue, CLzRef *items, size_t numItems);
-// void MatchFinder_ReduceOffsets(CMatchFinder *p, UInt32 subValue);
-
-/*
-#define Inline_MatchFinder_InitPos(p, val) \
-    (p)->pos = (val); \
-    (p)->streamPos = (val);
-*/
-
-#define Inline_MatchFinder_ReduceOffsets(p, subValue) \
-    (p)->pos -= (subValue); \
-    (p)->streamPos -= (subValue);
-
-
-UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *buffer, CLzRef *son,
-    size_t _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 _cutValue,
-    UInt32 *distances, UInt32 maxLen);
-
-/*
-Conditions:
-  Mf_GetNumAvailableBytes_Func must be called before each Mf_GetMatchLen_Func.
-  Mf_GetPointerToCurrentPos_Func's result must be used only before any other function
-*/
-
-typedef void (*Mf_Init_Func)(void *object);
-typedef UInt32 (*Mf_GetNumAvailableBytes_Func)(void *object);
-typedef const Byte * (*Mf_GetPointerToCurrentPos_Func)(void *object);
-typedef UInt32 * (*Mf_GetMatches_Func)(void *object, UInt32 *distances);
-typedef void (*Mf_Skip_Func)(void *object, UInt32);
-
-typedef struct _IMatchFinder
-{
-  Mf_Init_Func Init;
-  Mf_GetNumAvailableBytes_Func GetNumAvailableBytes;
-  Mf_GetPointerToCurrentPos_Func GetPointerToCurrentPos;
-  Mf_GetMatches_Func GetMatches;
-  Mf_Skip_Func Skip;
-} IMatchFinder2;
-
-void MatchFinder_CreateVTable(CMatchFinder *p, IMatchFinder2 *vTable);
-
-void MatchFinder_Init_LowHash(CMatchFinder *p);
-void MatchFinder_Init_HighHash(CMatchFinder *p);
-void MatchFinder_Init_4(CMatchFinder *p);
-void MatchFinder_Init(CMatchFinder *p);
-
-UInt32* Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances);
-UInt32* Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances);
-
-void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);
-void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);
-
-void LzFindPrepare(void);
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/LzFindMt.h

@@ -1,109 +0,0 @@
-/* LzFindMt.h -- multithreaded Match finder for LZ algorithms
-2021-07-12 : Igor Pavlov : Public domain */
-
-#ifndef __LZ_FIND_MT_H
-#define __LZ_FIND_MT_H
-
-#include "LzFind.h"
-#include "Threads.h"
-
-EXTERN_C_BEGIN
-
-typedef struct _CMtSync
-{
-  UInt32 numProcessedBlocks;
-  CThread thread;
-  UInt64 affinity;
-
-  BoolInt wasCreated;
-  BoolInt needStart;
-  BoolInt csWasInitialized;
-  BoolInt csWasEntered;
-
-  BoolInt exit;
-  BoolInt stopWriting;
-
-  CAutoResetEvent canStart;
-  CAutoResetEvent wasStopped;
-  CSemaphore freeSemaphore;
-  CSemaphore filledSemaphore;
-  CCriticalSection cs;
-  // UInt32 numBlocks_Sent;
-} CMtSync;
-
-typedef UInt32 * (*Mf_Mix_Matches)(void *p, UInt32 matchMinPos, UInt32 *distances);
-
-/* kMtCacheLineDummy must be >= size_of_CPU_cache_line */
-#define kMtCacheLineDummy 128
-
-typedef void (*Mf_GetHeads)(const Byte *buffer, UInt32 pos,
-  UInt32 *hash, UInt32 hashMask, UInt32 *heads, UInt32 numHeads, const UInt32 *crc);
-
-typedef struct _CMatchFinderMt
-{
-  /* LZ */
-  const Byte *pointerToCurPos;
-  UInt32 *btBuf;
-  const UInt32 *btBufPos;
-  const UInt32 *btBufPosLimit;
-  UInt32 lzPos;
-  UInt32 btNumAvailBytes;
-
-  UInt32 *hash;
-  UInt32 fixedHashSize;
-  // UInt32 hash4Mask;
-  UInt32 historySize;
-  const UInt32 *crc;
-
-  Mf_Mix_Matches MixMatchesFunc;
-  UInt32 failure_LZ_BT; // failure in BT transfered to LZ
-  // UInt32 failure_LZ_LZ; // failure in LZ tables
-  UInt32 failureBuf[1];
-  // UInt32 crc[256];
-
-  /* LZ + BT */
-  CMtSync btSync;
-  Byte btDummy[kMtCacheLineDummy];
-
-  /* BT */
-  UInt32 *hashBuf;
-  UInt32 hashBufPos;
-  UInt32 hashBufPosLimit;
-  UInt32 hashNumAvail;
-  UInt32 failure_BT;
-
-
-  CLzRef *son;
-  UInt32 matchMaxLen;
-  UInt32 numHashBytes;
-  UInt32 pos;
-  const Byte *buffer;
-  UInt32 cyclicBufferPos;
-  UInt32 cyclicBufferSize; /* it must be = (historySize + 1) */
-  UInt32 cutValue;
-
-  /* BT + Hash */
-  CMtSync hashSync;
-  /* Byte hashDummy[kMtCacheLineDummy]; */
-  
-  /* Hash */
-  Mf_GetHeads GetHeadsFunc;
-  CMatchFinder *MatchFinder;
-  // CMatchFinder MatchFinder;
-} CMatchFinderMt;
-
-// only for Mt part
-void MatchFinderMt_Construct(CMatchFinderMt *p);
-void MatchFinderMt_Destruct(CMatchFinderMt *p, ISzAllocPtr alloc);
-
-SRes MatchFinderMt_Create(CMatchFinderMt *p, UInt32 historySize, UInt32 keepAddBufferBefore,
-    UInt32 matchMaxLen, UInt32 keepAddBufferAfter, ISzAllocPtr alloc);
-void MatchFinderMt_CreateVTable(CMatchFinderMt *p, IMatchFinder2 *vTable);
-
-/* call MatchFinderMt_InitMt() before IMatchFinder::Init() */
-SRes MatchFinderMt_InitMt(CMatchFinderMt *p);
-void MatchFinderMt_ReleaseStream(CMatchFinderMt *p);
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/LzFindOpt.c

@@ -1,578 +0,0 @@
-/* LzFindOpt.c -- multithreaded Match finder for LZ algorithms
-2021-07-13 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "CpuArch.h"
-#include "LzFind.h"
-
-// #include "LzFindMt.h"
-
-// #define LOG_ITERS
-
-// #define LOG_THREAD
-
-#ifdef LOG_THREAD
-#include <stdio.h>
-#define PRF(x) x
-#else
-// #define PRF(x)
-#endif
-
-#ifdef LOG_ITERS
-#include <stdio.h>
-UInt64 g_NumIters_Tree;
-UInt64 g_NumIters_Loop;
-UInt64 g_NumIters_Bytes;
-#define LOG_ITER(x) x
-#else
-#define LOG_ITER(x)
-#endif
-
-// ---------- BT THREAD ----------
-
-#define USE_SON_PREFETCH
-#define USE_LONG_MATCH_OPT
-
-#define kEmptyHashValue 0
-
-// #define CYC_TO_POS_OFFSET 0
-
-// #define CYC_TO_POS_OFFSET 1 // for debug
-
-/*
-MY_NO_INLINE
-UInt32 * MY_FAST_CALL GetMatchesSpecN_1(const Byte *lenLimit, size_t pos, const Byte *cur, CLzRef *son,
-    UInt32 _cutValue, UInt32 *d, size_t _maxLen, const UInt32 *hash, const UInt32 *limit, const UInt32 *size, UInt32 *posRes)
-{
-  do
-  {
-    UInt32 delta;
-    if (hash == size)
-      break;
-    delta = *hash++;
-
-    if (delta == 0 || delta > (UInt32)pos)
-      return NULL;
-
-    lenLimit++;
-
-    if (delta == (UInt32)pos)
-    {
-      CLzRef *ptr1 = son + ((size_t)pos << 1) - CYC_TO_POS_OFFSET * 2;
-      *d++ = 0;
-      ptr1[0] = kEmptyHashValue;
-      ptr1[1] = kEmptyHashValue;
-    }
-else
-{
-  UInt32 *_distances = ++d;
-
-  CLzRef *ptr0 = son + ((size_t)(pos) << 1) - CYC_TO_POS_OFFSET * 2 + 1;
-  CLzRef *ptr1 = son + ((size_t)(pos) << 1) - CYC_TO_POS_OFFSET * 2;
-
-  const Byte *len0 = cur, *len1 = cur;
-  UInt32 cutValue = _cutValue;
-  const Byte *maxLen = cur + _maxLen;
-
-  for (LOG_ITER(g_NumIters_Tree++);;)
-  {
-    LOG_ITER(g_NumIters_Loop++);
-    {
-      const ptrdiff_t diff = (ptrdiff_t)0 - (ptrdiff_t)delta;
-      CLzRef *pair = son + ((size_t)(((ptrdiff_t)pos - CYC_TO_POS_OFFSET) + diff) << 1);
-      const Byte *len = (len0 < len1 ? len0 : len1);
-
-    #ifdef USE_SON_PREFETCH
-      const UInt32 pair0 = *pair;
-    #endif
-
-      if (len[diff] == len[0])
-      {
-        if (++len != lenLimit && len[diff] == len[0])
-          while (++len != lenLimit)
-          {
-            LOG_ITER(g_NumIters_Bytes++);
-            if (len[diff] != len[0])
-              break;
-          }
-        if (maxLen < len)
-        {
-          maxLen = len;
-          *d++ = (UInt32)(len - cur);
-          *d++ = delta - 1;
-          
-          if (len == lenLimit)
-          {
-            const UInt32 pair1 = pair[1];
-            *ptr1 =
-              #ifdef USE_SON_PREFETCH
-                pair0;
-              #else
-                pair[0];
-              #endif
-            *ptr0 = pair1;
-
-            _distances[-1] = (UInt32)(d - _distances);
-
-            #ifdef USE_LONG_MATCH_OPT
-
-                if (hash == size || *hash != delta || lenLimit[diff] != lenLimit[0] || d >= limit)
-                  break;
-
-            {
-              for (;;)
-              {
-                hash++;
-                pos++;
-                cur++;
-                lenLimit++;
-                {
-                  CLzRef *ptr = son + ((size_t)(pos) << 1) - CYC_TO_POS_OFFSET * 2;
-                  #if 0
-                  *(UInt64 *)(void *)ptr = ((const UInt64 *)(const void *)ptr)[diff];
-                  #else
-                  const UInt32 p0 = ptr[0 + (diff * 2)];
-                  const UInt32 p1 = ptr[1 + (diff * 2)];
-                  ptr[0] = p0;
-                  ptr[1] = p1;
-                  // ptr[0] = ptr[0 + (diff * 2)];
-                  // ptr[1] = ptr[1 + (diff * 2)];
-                  #endif
-                }
-                // PrintSon(son + 2, pos - 1);
-                // printf("\npos = %x delta = %x\n", pos, delta);
-                len++;
-                *d++ = 2;
-                *d++ = (UInt32)(len - cur);
-                *d++ = delta - 1;
-                if (hash == size || *hash != delta || lenLimit[diff] != lenLimit[0] || d >= limit)
-                  break;
-              }
-            }
-            #endif
-
-            break;
-          }
-        }
-      }
-
-      {
-        const UInt32 curMatch = (UInt32)pos - delta; // (UInt32)(pos + diff);
-        if (len[diff] < len[0])
-        {
-          delta = pair[1];
-          if (delta >= curMatch)
-            return NULL;
-          *ptr1 = curMatch;
-          ptr1 = pair + 1;
-          len1 = len;
-        }
-        else
-        {
-          delta = *pair;
-          if (delta >= curMatch)
-            return NULL;
-          *ptr0 = curMatch;
-          ptr0 = pair;
-          len0 = len;
-        }
-
-        delta = (UInt32)pos - delta;
- 
-        if (--cutValue == 0 || delta >= pos)
-        {
-          *ptr0 = *ptr1 = kEmptyHashValue;
-          _distances[-1] = (UInt32)(d - _distances);
-          break;
-        }
-      }
-    }
-  } // for (tree iterations)
-}
-    pos++;
-    cur++;
-  }
-  while (d < limit);
-  *posRes = (UInt32)pos;
-  return d;
-}
-*/
-
-/* define cbs if you use 2 functions.
-       GetMatchesSpecN_1() :  (pos <  _cyclicBufferSize)
-       GetMatchesSpecN_2() :  (pos >= _cyclicBufferSize)
-
-  do not define cbs if you use 1 function:
-       GetMatchesSpecN_2()
-*/
-
-// #define cbs _cyclicBufferSize
-
-/*
-  we use size_t for (pos) and (_cyclicBufferPos_ instead of UInt32
-  to eliminate "movsx" BUG in old MSVC x64 compiler.
-*/
-
-UInt32 * MY_FAST_CALL GetMatchesSpecN_2(const Byte *lenLimit, size_t pos, const Byte *cur, CLzRef *son,
-    UInt32 _cutValue, UInt32 *d, size_t _maxLen, const UInt32 *hash, const UInt32 *limit, const UInt32 *size,
-    size_t _cyclicBufferPos, UInt32 _cyclicBufferSize,
-    UInt32 *posRes);
-
-MY_NO_INLINE
-UInt32 * MY_FAST_CALL GetMatchesSpecN_2(const Byte *lenLimit, size_t pos, const Byte *cur, CLzRef *son,
-    UInt32 _cutValue, UInt32 *d, size_t _maxLen, const UInt32 *hash, const UInt32 *limit, const UInt32 *size,
-    size_t _cyclicBufferPos, UInt32 _cyclicBufferSize,
-    UInt32 *posRes)
-{
-  do // while (hash != size)
-  {
-    UInt32 delta;
-    
-  #ifndef cbs
-    UInt32 cbs;
-  #endif
-
-    if (hash == size)
-      break;
-
-    delta = *hash++;
-
-    if (delta == 0)
-      return NULL;
-
-    lenLimit++;
-
-  #ifndef cbs
-    cbs = _cyclicBufferSize;
-    if ((UInt32)pos < cbs)
-    {
-      if (delta > (UInt32)pos)
-        return NULL;
-      cbs = (UInt32)pos;
-    }
-  #endif
-
-    if (delta >= cbs)
-    {
-      CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1);
-      *d++ = 0;
-      ptr1[0] = kEmptyHashValue;
-      ptr1[1] = kEmptyHashValue;
-    }
-else
-{
-  UInt32 *_distances = ++d;
-
-  CLzRef *ptr0 = son + ((size_t)_cyclicBufferPos << 1) + 1;
-  CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1);
-
-  UInt32 cutValue = _cutValue;
-  const Byte *len0 = cur, *len1 = cur;
-  const Byte *maxLen = cur + _maxLen;
-
-  // if (cutValue == 0) { *ptr0 = *ptr1 = kEmptyHashValue; } else
-  for (LOG_ITER(g_NumIters_Tree++);;)
-  {
-    LOG_ITER(g_NumIters_Loop++);
-    {
-      // SPEC code
-      CLzRef *pair = son + ((size_t)((ptrdiff_t)_cyclicBufferPos - (ptrdiff_t)delta
-          + (ptrdiff_t)(UInt32)(_cyclicBufferPos < delta ? cbs : 0)
-          ) << 1);
-
-      const ptrdiff_t diff = (ptrdiff_t)0 - (ptrdiff_t)delta;
-      const Byte *len = (len0 < len1 ? len0 : len1);
-
-    #ifdef USE_SON_PREFETCH
-      const UInt32 pair0 = *pair;
-    #endif
-
-      if (len[diff] == len[0])
-      {
-        if (++len != lenLimit && len[diff] == len[0])
-          while (++len != lenLimit)
-          {
-            LOG_ITER(g_NumIters_Bytes++);
-            if (len[diff] != len[0])
-              break;
-          }
-        if (maxLen < len)
-        {
-          maxLen = len;
-          *d++ = (UInt32)(len - cur);
-          *d++ = delta - 1;
-          
-          if (len == lenLimit)
-          {
-            const UInt32 pair1 = pair[1];
-            *ptr1 =
-              #ifdef USE_SON_PREFETCH
-                pair0;
-              #else
-                pair[0];
-              #endif
-            *ptr0 = pair1;
-
-            _distances[-1] = (UInt32)(d - _distances);
-
-            #ifdef USE_LONG_MATCH_OPT
-
-                if (hash == size || *hash != delta || lenLimit[diff] != lenLimit[0] || d >= limit)
-                  break;
-
-            {
-              for (;;)
-              {
-                *d++ = 2;
-                *d++ = (UInt32)(lenLimit - cur);
-                *d++ = delta - 1;
-                cur++;
-                lenLimit++;
-                // SPEC
-                _cyclicBufferPos++;
-                {
-                  // SPEC code
-                  CLzRef *dest = son + ((size_t)(_cyclicBufferPos) << 1);
-                  const CLzRef *src = dest + ((diff
-                      + (ptrdiff_t)(UInt32)((_cyclicBufferPos < delta) ? cbs : 0)) << 1);
-                  // CLzRef *ptr = son + ((size_t)(pos) << 1) - CYC_TO_POS_OFFSET * 2;
-                  #if 0
-                  *(UInt64 *)(void *)dest = *((const UInt64 *)(const void *)src);
-                  #else
-                  const UInt32 p0 = src[0];
-                  const UInt32 p1 = src[1];
-                  dest[0] = p0;
-                  dest[1] = p1;
-                  #endif
-                }
-                pos++;
-                hash++;
-                if (hash == size || *hash != delta || lenLimit[diff] != lenLimit[0] || d >= limit)
-                  break;
-              } // for() end for long matches
-            }
-            #endif
-
-            break; // break from TREE iterations
-          }
-        }
-      }
-      {
-        const UInt32 curMatch = (UInt32)pos - delta; // (UInt32)(pos + diff);
-        if (len[diff] < len[0])
-        {
-          delta = pair[1];
-          *ptr1 = curMatch;
-          ptr1 = pair + 1;
-          len1 = len;
-          if (delta >= curMatch)
-            return NULL;
-        }
-        else
-        {
-          delta = *pair;
-          *ptr0 = curMatch;
-          ptr0 = pair;
-          len0 = len;
-          if (delta >= curMatch)
-            return NULL;
-        }
-        delta = (UInt32)pos - delta;
- 
-        if (--cutValue == 0 || delta >= cbs)
-        {
-          *ptr0 = *ptr1 = kEmptyHashValue;
-          _distances[-1] = (UInt32)(d - _distances);
-          break;
-        }
-      }
-    }
-  } // for (tree iterations)
-}
-    pos++;
-    _cyclicBufferPos++;
-    cur++;
-  }
-  while (d < limit);
-  *posRes = (UInt32)pos;
-  return d;
-}
-
-
-
-/*
-typedef UInt32 uint32plus; // size_t
-
-UInt32 * MY_FAST_CALL GetMatchesSpecN_3(uint32plus lenLimit, size_t pos, const Byte *cur, CLzRef *son,
-    UInt32 _cutValue, UInt32 *d, uint32plus _maxLen, const UInt32 *hash, const UInt32 *limit, const UInt32 *size,
-    size_t _cyclicBufferPos, UInt32 _cyclicBufferSize,
-    UInt32 *posRes)
-{
-  do // while (hash != size)
-  {
-    UInt32 delta;
-
-  #ifndef cbs
-    UInt32 cbs;
-  #endif
-
-    if (hash == size)
-      break;
-
-    delta = *hash++;
-
-    if (delta == 0)
-      return NULL;
-
-  #ifndef cbs
-    cbs = _cyclicBufferSize;
-    if ((UInt32)pos < cbs)
-    {
-      if (delta > (UInt32)pos)
-        return NULL;
-      cbs = (UInt32)pos;
-    }
-  #endif
-    
-    if (delta >= cbs)
-    {
-      CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1);
-      *d++ = 0;
-      ptr1[0] = kEmptyHashValue;
-      ptr1[1] = kEmptyHashValue;
-    }
-else
-{
-  CLzRef *ptr0 = son + ((size_t)_cyclicBufferPos << 1) + 1;
-  CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1);
-  UInt32 *_distances = ++d;
-  uint32plus len0 = 0, len1 = 0;
-  UInt32 cutValue = _cutValue;
-  uint32plus maxLen = _maxLen;
-  // lenLimit++; // const Byte *lenLimit = cur + _lenLimit;
-
-  for (LOG_ITER(g_NumIters_Tree++);;)
-  {
-    LOG_ITER(g_NumIters_Loop++);
-    {
-      // const ptrdiff_t diff = (ptrdiff_t)0 - (ptrdiff_t)delta;
-      CLzRef *pair = son + ((size_t)((ptrdiff_t)_cyclicBufferPos - delta
-          + (ptrdiff_t)(UInt32)(_cyclicBufferPos < delta ? cbs : 0)
-          ) << 1);
-      const Byte *pb = cur - delta;
-      uint32plus len = (len0 < len1 ? len0 : len1);
-
-    #ifdef USE_SON_PREFETCH
-      const UInt32 pair0 = *pair;
-    #endif
-
-      if (pb[len] == cur[len])
-      {
-        if (++len != lenLimit && pb[len] == cur[len])
-          while (++len != lenLimit)
-            if (pb[len] != cur[len])
-              break;
-        if (maxLen < len)
-        {
-          maxLen = len;
-          *d++ = (UInt32)len;
-          *d++ = delta - 1;
-          if (len == lenLimit)
-          {
-            {
-              const UInt32 pair1 = pair[1];
-              *ptr0 = pair1;
-              *ptr1 =
-              #ifdef USE_SON_PREFETCH
-                pair0;
-              #else
-                pair[0];
-              #endif
-            }
-
-            _distances[-1] = (UInt32)(d - _distances);
-
-            #ifdef USE_LONG_MATCH_OPT
-
-                if (hash == size || *hash != delta || pb[lenLimit] != cur[lenLimit] || d >= limit)
-                  break;
-
-            {
-              const ptrdiff_t diff = (ptrdiff_t)0 - (ptrdiff_t)delta;
-              for (;;)
-              {
-                *d++ = 2;
-                *d++ = (UInt32)lenLimit;
-                *d++ = delta - 1;
-                _cyclicBufferPos++;
-                {
-                  CLzRef *dest = son + ((size_t)_cyclicBufferPos << 1);
-                  const CLzRef *src = dest + ((diff +
-                      (ptrdiff_t)(UInt32)(_cyclicBufferPos < delta ? cbs : 0)) << 1);
-                #if 0
-                  *(UInt64 *)(void *)dest = *((const UInt64 *)(const void *)src);
-                #else
-                  const UInt32 p0 = src[0];
-                  const UInt32 p1 = src[1];
-                  dest[0] = p0;
-                  dest[1] = p1;
-                #endif
-                }
-                hash++;
-                pos++;
-                cur++;
-                pb++;
-                if (hash == size || *hash != delta || pb[lenLimit] != cur[lenLimit] || d >= limit)
-                  break;
-              }
-            }
-            #endif
-
-            break;
-          }
-        }
-      }
-      {
-        const UInt32 curMatch = (UInt32)pos - delta;
-        if (pb[len] < cur[len])
-        {
-          delta = pair[1];
-          *ptr1 = curMatch;
-          ptr1 = pair + 1;
-          len1 = len;
-        }
-        else
-        {
-          delta = *pair;
-          *ptr0 = curMatch;
-          ptr0 = pair;
-          len0 = len;
-        }
-
-        {
-          if (delta >= curMatch)
-            return NULL;
-          delta = (UInt32)pos - delta;
-          if (delta >= cbs
-              // delta >= _cyclicBufferSize || delta >= pos
-              || --cutValue == 0)
-          {
-            *ptr0 = *ptr1 = kEmptyHashValue;
-            _distances[-1] = (UInt32)(d - _distances);
-            break;
-          }
-        }
-      }
-    }
-  } // for (tree iterations)
-}
-    pos++;
-    _cyclicBufferPos++;
-    cur++;
-  }
-  while (d < limit);
-  *posRes = (UInt32)pos;
-  return d;
-}
-*/

3rdparty/7z/src/LzHash.h

@@ -1,34 +0,0 @@
-/* LzHash.h -- HASH functions for LZ algorithms
-2019-10-30 : Igor Pavlov : Public domain */
-
-#ifndef __LZ_HASH_H
-#define __LZ_HASH_H
-
-/*
-  (kHash2Size >= (1 <<  8)) : Required
-  (kHash3Size >= (1 << 16)) : Required
-*/
-
-#define kHash2Size (1 << 10)
-#define kHash3Size (1 << 16)
-// #define kHash4Size (1 << 20)
-
-#define kFix3HashSize (kHash2Size)
-#define kFix4HashSize (kHash2Size + kHash3Size)
-// #define kFix5HashSize (kHash2Size + kHash3Size + kHash4Size)
-
-/*
-  We use up to 3 crc values for hash:
-    crc0
-    crc1 << Shift_1
-    crc2 << Shift_2
-  (Shift_1 = 5) and (Shift_2 = 10) is good tradeoff.
-  Small values for Shift are not good for collision rate.
-  Big value for Shift_2 increases the minimum size
-  of hash table, that will be slow for small files.
-*/
-
-#define kLzHash_CrcShift_1 5
-#define kLzHash_CrcShift_2 10
-
-#endif

3rdparty/7z/src/Lzma2Dec.c

@@ -1,489 +0,0 @@
-/* Lzma2Dec.c -- LZMA2 Decoder
-2021-02-09 : Igor Pavlov : Public domain */
-
-/* #define SHOW_DEBUG_INFO */
-
-#include "Precomp.h"
-
-#ifdef SHOW_DEBUG_INFO
-#include <stdio.h>
-#endif
-
-#include <string.h>
-
-#include "Lzma2Dec.h"
-
-/*
-00000000  -  End of data
-00000001 U U  -  Uncompressed, reset dic, need reset state and set new prop
-00000010 U U  -  Uncompressed, no reset
-100uuuuu U U P P  -  LZMA, no reset
-101uuuuu U U P P  -  LZMA, reset state
-110uuuuu U U P P S  -  LZMA, reset state + set new prop
-111uuuuu U U P P S  -  LZMA, reset state + set new prop, reset dic
-
-  u, U - Unpack Size
-  P - Pack Size
-  S - Props
-*/
-
-#define LZMA2_CONTROL_COPY_RESET_DIC 1
-
-#define LZMA2_IS_UNCOMPRESSED_STATE(p) (((p)->control & (1 << 7)) == 0)
-
-#define LZMA2_LCLP_MAX 4
-#define LZMA2_DIC_SIZE_FROM_PROP(p) (((UInt32)2 | ((p) & 1)) << ((p) / 2 + 11))
-
-#ifdef SHOW_DEBUG_INFO
-#define PRF(x) x
-#else
-#define PRF(x)
-#endif
-
-typedef enum
-{
-  LZMA2_STATE_CONTROL,
-  LZMA2_STATE_UNPACK0,
-  LZMA2_STATE_UNPACK1,
-  LZMA2_STATE_PACK0,
-  LZMA2_STATE_PACK1,
-  LZMA2_STATE_PROP,
-  LZMA2_STATE_DATA,
-  LZMA2_STATE_DATA_CONT,
-  LZMA2_STATE_FINISHED,
-  LZMA2_STATE_ERROR
-} ELzma2State;
-
-static SRes Lzma2Dec_GetOldProps(Byte prop, Byte *props)
-{
-  UInt32 dicSize;
-  if (prop > 40)
-    return SZ_ERROR_UNSUPPORTED;
-  dicSize = (prop == 40) ? 0xFFFFFFFF : LZMA2_DIC_SIZE_FROM_PROP(prop);
-  props[0] = (Byte)LZMA2_LCLP_MAX;
-  props[1] = (Byte)(dicSize);
-  props[2] = (Byte)(dicSize >> 8);
-  props[3] = (Byte)(dicSize >> 16);
-  props[4] = (Byte)(dicSize >> 24);
-  return SZ_OK;
-}
-
-SRes Lzma2Dec_AllocateProbs(CLzma2Dec *p, Byte prop, ISzAllocPtr alloc)
-{
-  Byte props[LZMA_PROPS_SIZE];
-  RINOK(Lzma2Dec_GetOldProps(prop, props));
-  return LzmaDec_AllocateProbs(&p->decoder, props, LZMA_PROPS_SIZE, alloc);
-}
-
-SRes Lzma2Dec_Allocate(CLzma2Dec *p, Byte prop, ISzAllocPtr alloc)
-{
-  Byte props[LZMA_PROPS_SIZE];
-  RINOK(Lzma2Dec_GetOldProps(prop, props));
-  return LzmaDec_Allocate(&p->decoder, props, LZMA_PROPS_SIZE, alloc);
-}
-
-void Lzma2Dec_Init(CLzma2Dec *p)
-{
-  p->state = LZMA2_STATE_CONTROL;
-  p->needInitLevel = 0xE0;
-  p->isExtraMode = False;
-  p->unpackSize = 0;
-  
-  // p->decoder.dicPos = 0; // we can use it instead of full init
-  LzmaDec_Init(&p->decoder);
-}
-
-// ELzma2State
-static unsigned Lzma2Dec_UpdateState(CLzma2Dec *p, Byte b)
-{
-  switch (p->state)
-  {
-    case LZMA2_STATE_CONTROL:
-      p->isExtraMode = False;
-      p->control = b;
-      PRF(printf("\n %8X", (unsigned)p->decoder.dicPos));
-      PRF(printf(" %02X", (unsigned)b));
-      if (b == 0)
-        return LZMA2_STATE_FINISHED;
-      if (LZMA2_IS_UNCOMPRESSED_STATE(p))
-      {
-        if (b == LZMA2_CONTROL_COPY_RESET_DIC)
-          p->needInitLevel = 0xC0;
-        else if (b > 2 || p->needInitLevel == 0xE0)
-          return LZMA2_STATE_ERROR;
-      }
-      else
-      {
-        if (b < p->needInitLevel)
-          return LZMA2_STATE_ERROR;
-        p->needInitLevel = 0;
-        p->unpackSize = (UInt32)(b & 0x1F) << 16;
-      }
-      return LZMA2_STATE_UNPACK0;
-    
-    case LZMA2_STATE_UNPACK0:
-      p->unpackSize |= (UInt32)b << 8;
-      return LZMA2_STATE_UNPACK1;
-    
-    case LZMA2_STATE_UNPACK1:
-      p->unpackSize |= (UInt32)b;
-      p->unpackSize++;
-      PRF(printf(" %7u", (unsigned)p->unpackSize));
-      return LZMA2_IS_UNCOMPRESSED_STATE(p) ? LZMA2_STATE_DATA : LZMA2_STATE_PACK0;
-    
-    case LZMA2_STATE_PACK0:
-      p->packSize = (UInt32)b << 8;
-      return LZMA2_STATE_PACK1;
-
-    case LZMA2_STATE_PACK1:
-      p->packSize |= (UInt32)b;
-      p->packSize++;
-      // if (p->packSize < 5) return LZMA2_STATE_ERROR;
-      PRF(printf(" %5u", (unsigned)p->packSize));
-      return (p->control & 0x40) ? LZMA2_STATE_PROP : LZMA2_STATE_DATA;
-
-    case LZMA2_STATE_PROP:
-    {
-      unsigned lc, lp;
-      if (b >= (9 * 5 * 5))
-        return LZMA2_STATE_ERROR;
-      lc = b % 9;
-      b /= 9;
-      p->decoder.prop.pb = (Byte)(b / 5);
-      lp = b % 5;
-      if (lc + lp > LZMA2_LCLP_MAX)
-        return LZMA2_STATE_ERROR;
-      p->decoder.prop.lc = (Byte)lc;
-      p->decoder.prop.lp = (Byte)lp;
-      return LZMA2_STATE_DATA;
-    }
-  }
-  return LZMA2_STATE_ERROR;
-}
-
-static void LzmaDec_UpdateWithUncompressed(CLzmaDec *p, const Byte *src, SizeT size)
-{
-  memcpy(p->dic + p->dicPos, src, size);
-  p->dicPos += size;
-  if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= size)
-    p->checkDicSize = p->prop.dicSize;
-  p->processedPos += (UInt32)size;
-}
-
-void LzmaDec_InitDicAndState(CLzmaDec *p, BoolInt initDic, BoolInt initState);
-
-
-SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit,
-    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)
-{
-  SizeT inSize = *srcLen;
-  *srcLen = 0;
-  *status = LZMA_STATUS_NOT_SPECIFIED;
-
-  while (p->state != LZMA2_STATE_ERROR)
-  {
-    SizeT dicPos;
-
-    if (p->state == LZMA2_STATE_FINISHED)
-    {
-      *status = LZMA_STATUS_FINISHED_WITH_MARK;
-      return SZ_OK;
-    }
-    
-    dicPos = p->decoder.dicPos;
-    
-    if (dicPos == dicLimit && finishMode == LZMA_FINISH_ANY)
-    {
-      *status = LZMA_STATUS_NOT_FINISHED;
-      return SZ_OK;
-    }
-
-    if (p->state != LZMA2_STATE_DATA && p->state != LZMA2_STATE_DATA_CONT)
-    {
-      if (*srcLen == inSize)
-      {
-        *status = LZMA_STATUS_NEEDS_MORE_INPUT;
-        return SZ_OK;
-      }
-      (*srcLen)++;
-      p->state = Lzma2Dec_UpdateState(p, *src++);
-      if (dicPos == dicLimit && p->state != LZMA2_STATE_FINISHED)
-        break;
-      continue;
-    }
-    
-    {
-      SizeT inCur = inSize - *srcLen;
-      SizeT outCur = dicLimit - dicPos;
-      ELzmaFinishMode curFinishMode = LZMA_FINISH_ANY;
-      
-      if (outCur >= p->unpackSize)
-      {
-        outCur = (SizeT)p->unpackSize;
-        curFinishMode = LZMA_FINISH_END;
-      }
-
-      if (LZMA2_IS_UNCOMPRESSED_STATE(p))
-      {
-        if (inCur == 0)
-        {
-          *status = LZMA_STATUS_NEEDS_MORE_INPUT;
-          return SZ_OK;
-        }
-
-        if (p->state == LZMA2_STATE_DATA)
-        {
-          BoolInt initDic = (p->control == LZMA2_CONTROL_COPY_RESET_DIC);
-          LzmaDec_InitDicAndState(&p->decoder, initDic, False);
-        }
-
-        if (inCur > outCur)
-          inCur = outCur;
-        if (inCur == 0)
-          break;
-
-        LzmaDec_UpdateWithUncompressed(&p->decoder, src, inCur);
-
-        src += inCur;
-        *srcLen += inCur;
-        p->unpackSize -= (UInt32)inCur;
-        p->state = (p->unpackSize == 0) ? LZMA2_STATE_CONTROL : LZMA2_STATE_DATA_CONT;
-      }
-      else
-      {
-        SRes res;
-
-        if (p->state == LZMA2_STATE_DATA)
-        {
-          BoolInt initDic = (p->control >= 0xE0);
-          BoolInt initState = (p->control >= 0xA0);
-          LzmaDec_InitDicAndState(&p->decoder, initDic, initState);
-          p->state = LZMA2_STATE_DATA_CONT;
-        }
-  
-        if (inCur > p->packSize)
-          inCur = (SizeT)p->packSize;
-        
-        res = LzmaDec_DecodeToDic(&p->decoder, dicPos + outCur, src, &inCur, curFinishMode, status);
-
-        src += inCur;
-        *srcLen += inCur;
-        p->packSize -= (UInt32)inCur;
-        outCur = p->decoder.dicPos - dicPos;
-        p->unpackSize -= (UInt32)outCur;
-
-        if (res != 0)
-          break;
-        
-        if (*status == LZMA_STATUS_NEEDS_MORE_INPUT)
-        {
-          if (p->packSize == 0)
-            break;
-          return SZ_OK;
-        }
-
-        if (inCur == 0 && outCur == 0)
-        {
-          if (*status != LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK
-              || p->unpackSize != 0
-              || p->packSize != 0)
-            break;
-          p->state = LZMA2_STATE_CONTROL;
-        }
-        
-        *status = LZMA_STATUS_NOT_SPECIFIED;
-      }
-    }
-  }
-  
-  *status = LZMA_STATUS_NOT_SPECIFIED;
-  p->state = LZMA2_STATE_ERROR;
-  return SZ_ERROR_DATA;
-}
-
-
-
-
-ELzma2ParseStatus Lzma2Dec_Parse(CLzma2Dec *p,
-    SizeT outSize,
-    const Byte *src, SizeT *srcLen,
-    int checkFinishBlock)
-{
-  SizeT inSize = *srcLen;
-  *srcLen = 0;
-
-  while (p->state != LZMA2_STATE_ERROR)
-  {
-    if (p->state == LZMA2_STATE_FINISHED)
-      return (ELzma2ParseStatus)LZMA_STATUS_FINISHED_WITH_MARK;
-
-    if (outSize == 0 && !checkFinishBlock)
-      return (ELzma2ParseStatus)LZMA_STATUS_NOT_FINISHED;
-    
-    if (p->state != LZMA2_STATE_DATA && p->state != LZMA2_STATE_DATA_CONT)
-    {
-      if (*srcLen == inSize)
-        return (ELzma2ParseStatus)LZMA_STATUS_NEEDS_MORE_INPUT;
-      (*srcLen)++;
-
-      p->state = Lzma2Dec_UpdateState(p, *src++);
-
-      if (p->state == LZMA2_STATE_UNPACK0)
-      {
-        // if (p->decoder.dicPos != 0)
-        if (p->control == LZMA2_CONTROL_COPY_RESET_DIC || p->control >= 0xE0)
-          return LZMA2_PARSE_STATUS_NEW_BLOCK;
-        // if (outSize == 0) return LZMA_STATUS_NOT_FINISHED;
-      }
-
-      // The following code can be commented.
-      // It's not big problem, if we read additional input bytes.
-      // It will be stopped later in LZMA2_STATE_DATA / LZMA2_STATE_DATA_CONT state.
-
-      if (outSize == 0 && p->state != LZMA2_STATE_FINISHED)
-      {
-        // checkFinishBlock is true. So we expect that block must be finished,
-        // We can return LZMA_STATUS_NOT_SPECIFIED or LZMA_STATUS_NOT_FINISHED here
-        // break;
-        return (ELzma2ParseStatus)LZMA_STATUS_NOT_FINISHED;
-      }
-
-      if (p->state == LZMA2_STATE_DATA)
-        return LZMA2_PARSE_STATUS_NEW_CHUNK;
-
-      continue;
-    }
-
-    if (outSize == 0)
-      return (ELzma2ParseStatus)LZMA_STATUS_NOT_FINISHED;
-
-    {
-      SizeT inCur = inSize - *srcLen;
-
-      if (LZMA2_IS_UNCOMPRESSED_STATE(p))
-      {
-        if (inCur == 0)
-          return (ELzma2ParseStatus)LZMA_STATUS_NEEDS_MORE_INPUT;
-        if (inCur > p->unpackSize)
-          inCur = p->unpackSize;
-        if (inCur > outSize)
-          inCur = outSize;
-        p->decoder.dicPos += inCur;
-        src += inCur;
-        *srcLen += inCur;
-        outSize -= inCur;
-        p->unpackSize -= (UInt32)inCur;
-        p->state = (p->unpackSize == 0) ? LZMA2_STATE_CONTROL : LZMA2_STATE_DATA_CONT;
-      }
-      else
-      {
-        p->isExtraMode = True;
-
-        if (inCur == 0)
-        {
-          if (p->packSize != 0)
-            return (ELzma2ParseStatus)LZMA_STATUS_NEEDS_MORE_INPUT;
-        }
-        else if (p->state == LZMA2_STATE_DATA)
-        {
-          p->state = LZMA2_STATE_DATA_CONT;
-          if (*src != 0)
-          {
-            // first byte of lzma chunk must be Zero
-            *srcLen += 1;
-            p->packSize--;
-            break;
-          }
-        }
-  
-        if (inCur > p->packSize)
-          inCur = (SizeT)p->packSize;
-
-        src += inCur;
-        *srcLen += inCur;
-        p->packSize -= (UInt32)inCur;
-
-        if (p->packSize == 0)
-        {
-          SizeT rem = outSize;
-          if (rem > p->unpackSize)
-            rem = p->unpackSize;
-          p->decoder.dicPos += rem;
-          p->unpackSize -= (UInt32)rem;
-          outSize -= rem;
-          if (p->unpackSize == 0)
-            p->state = LZMA2_STATE_CONTROL;
-        }
-      }
-    }
-  }
-  
-  p->state = LZMA2_STATE_ERROR;
-  return (ELzma2ParseStatus)LZMA_STATUS_NOT_SPECIFIED;
-}
-
-
-
-
-SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)
-{
-  SizeT outSize = *destLen, inSize = *srcLen;
-  *srcLen = *destLen = 0;
-  
-  for (;;)
-  {
-    SizeT inCur = inSize, outCur, dicPos;
-    ELzmaFinishMode curFinishMode;
-    SRes res;
-    
-    if (p->decoder.dicPos == p->decoder.dicBufSize)
-      p->decoder.dicPos = 0;
-    dicPos = p->decoder.dicPos;
-    curFinishMode = LZMA_FINISH_ANY;
-    outCur = p->decoder.dicBufSize - dicPos;
-    
-    if (outCur >= outSize)
-    {
-      outCur = outSize;
-      curFinishMode = finishMode;
-    }
-
-    res = Lzma2Dec_DecodeToDic(p, dicPos + outCur, src, &inCur, curFinishMode, status);
-    
-    src += inCur;
-    inSize -= inCur;
-    *srcLen += inCur;
-    outCur = p->decoder.dicPos - dicPos;
-    memcpy(dest, p->decoder.dic + dicPos, outCur);
-    dest += outCur;
-    outSize -= outCur;
-    *destLen += outCur;
-    if (res != 0)
-      return res;
-    if (outCur == 0 || outSize == 0)
-      return SZ_OK;
-  }
-}
-
-
-SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
-    Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAllocPtr alloc)
-{
-  CLzma2Dec p;
-  SRes res;
-  SizeT outSize = *destLen, inSize = *srcLen;
-  *destLen = *srcLen = 0;
-  *status = LZMA_STATUS_NOT_SPECIFIED;
-  Lzma2Dec_Construct(&p);
-  RINOK(Lzma2Dec_AllocateProbs(&p, prop, alloc));
-  p.decoder.dic = dest;
-  p.decoder.dicBufSize = outSize;
-  Lzma2Dec_Init(&p);
-  *srcLen = inSize;
-  res = Lzma2Dec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status);
-  *destLen = p.decoder.dicPos;
-  if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT)
-    res = SZ_ERROR_INPUT_EOF;
-  Lzma2Dec_FreeProbs(&p, alloc);
-  return res;
-}

3rdparty/7z/src/Lzma2Dec.h

@@ -1,120 +0,0 @@
-/* Lzma2Dec.h -- LZMA2 Decoder
-2018-02-19 : Igor Pavlov : Public domain */
-
-#ifndef __LZMA2_DEC_H
-#define __LZMA2_DEC_H
-
-#include "LzmaDec.h"
-
-EXTERN_C_BEGIN
-
-/* ---------- State Interface ---------- */
-
-typedef struct
-{
-  unsigned state;
-  Byte control;
-  Byte needInitLevel;
-  Byte isExtraMode;
-  Byte _pad_;
-  UInt32 packSize;
-  UInt32 unpackSize;
-  CLzmaDec decoder;
-} CLzma2Dec;
-
-#define Lzma2Dec_Construct(p) LzmaDec_Construct(&(p)->decoder)
-#define Lzma2Dec_FreeProbs(p, alloc) LzmaDec_FreeProbs(&(p)->decoder, alloc)
-#define Lzma2Dec_Free(p, alloc) LzmaDec_Free(&(p)->decoder, alloc)
-
-SRes Lzma2Dec_AllocateProbs(CLzma2Dec *p, Byte prop, ISzAllocPtr alloc);
-SRes Lzma2Dec_Allocate(CLzma2Dec *p, Byte prop, ISzAllocPtr alloc);
-void Lzma2Dec_Init(CLzma2Dec *p);
-
-/*
-finishMode:
-  It has meaning only if the decoding reaches output limit (*destLen or dicLimit).
-  LZMA_FINISH_ANY - use smallest number of input bytes
-  LZMA_FINISH_END - read EndOfStream marker after decoding
-
-Returns:
-  SZ_OK
-    status:
-      LZMA_STATUS_FINISHED_WITH_MARK
-      LZMA_STATUS_NOT_FINISHED
-      LZMA_STATUS_NEEDS_MORE_INPUT
-  SZ_ERROR_DATA - Data error
-*/
-
-SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit,
-    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
-
-SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen,
-    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
-
-
-/* ---------- LZMA2 block and chunk parsing ---------- */
-
-/*
-Lzma2Dec_Parse() parses compressed data stream up to next independent block or next chunk data.
-It can return LZMA_STATUS_* code or LZMA2_PARSE_STATUS_* code:
-  - LZMA2_PARSE_STATUS_NEW_BLOCK - there is new block, and 1 additional byte (control byte of next block header) was read from input.
-  - LZMA2_PARSE_STATUS_NEW_CHUNK - there is new chunk, and only lzma2 header of new chunk was read.
-                                   CLzma2Dec::unpackSize contains unpack size of that chunk
-*/
-
-typedef enum
-{
-/*
-  LZMA_STATUS_NOT_SPECIFIED                 // data error
-  LZMA_STATUS_FINISHED_WITH_MARK
-  LZMA_STATUS_NOT_FINISHED                  //
-  LZMA_STATUS_NEEDS_MORE_INPUT
-  LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK   // unused
-*/
-  LZMA2_PARSE_STATUS_NEW_BLOCK = LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK + 1,
-  LZMA2_PARSE_STATUS_NEW_CHUNK
-} ELzma2ParseStatus;
-
-ELzma2ParseStatus Lzma2Dec_Parse(CLzma2Dec *p,
-    SizeT outSize,   // output size
-    const Byte *src, SizeT *srcLen,
-    int checkFinishBlock   // set (checkFinishBlock = 1), if it must read full input data, if decoder.dicPos reaches blockMax position.
-    );
-
-/*
-LZMA2 parser doesn't decode LZMA chunks, so we must read
-  full input LZMA chunk to decode some part of LZMA chunk.
-
-Lzma2Dec_GetUnpackExtra() returns the value that shows
-    max possible number of output bytes that can be output by decoder
-    at current input positon.
-*/
-
-#define Lzma2Dec_GetUnpackExtra(p) ((p)->isExtraMode ? (p)->unpackSize : 0);
-
-
-/* ---------- One Call Interface ---------- */
-
-/*
-finishMode:
-  It has meaning only if the decoding reaches output limit (*destLen).
-  LZMA_FINISH_ANY - use smallest number of input bytes
-  LZMA_FINISH_END - read EndOfStream marker after decoding
-
-Returns:
-  SZ_OK
-    status:
-      LZMA_STATUS_FINISHED_WITH_MARK
-      LZMA_STATUS_NOT_FINISHED
-  SZ_ERROR_DATA - Data error
-  SZ_ERROR_MEM  - Memory allocation error
-  SZ_ERROR_UNSUPPORTED - Unsupported properties
-  SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).
-*/
-
-SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
-    Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAllocPtr alloc);
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/Lzma2DecMt.h

@@ -1,79 +0,0 @@
-/* Lzma2DecMt.h -- LZMA2 Decoder Multi-thread
-2018-02-17 : Igor Pavlov : Public domain */
-
-#ifndef __LZMA2_DEC_MT_H
-#define __LZMA2_DEC_MT_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-typedef struct
-{
-  size_t inBufSize_ST;
-  size_t outStep_ST;
-  
-  #ifndef _7ZIP_ST
-  unsigned numThreads;
-  size_t inBufSize_MT;
-  size_t outBlockMax;
-  size_t inBlockMax;
-  #endif
-} CLzma2DecMtProps;
-
-/* init to single-thread mode */
-void Lzma2DecMtProps_Init(CLzma2DecMtProps *p);
-
-
-/* ---------- CLzma2DecMtHandle Interface ---------- */
-
-/* Lzma2DecMt_ * functions can return the following exit codes:
-SRes:
-  SZ_OK           - OK
-  SZ_ERROR_MEM    - Memory allocation error
-  SZ_ERROR_PARAM  - Incorrect paramater in props
-  SZ_ERROR_WRITE  - ISeqOutStream write callback error
-  // SZ_ERROR_OUTPUT_EOF - output buffer overflow - version with (Byte *) output
-  SZ_ERROR_PROGRESS - some break from progress callback
-  SZ_ERROR_THREAD - error in multithreading functions (only for Mt version)
-*/
-
-typedef void * CLzma2DecMtHandle;
-
-CLzma2DecMtHandle Lzma2DecMt_Create(ISzAllocPtr alloc, ISzAllocPtr allocMid);
-void Lzma2DecMt_Destroy(CLzma2DecMtHandle p);
-
-SRes Lzma2DecMt_Decode(CLzma2DecMtHandle p,
-    Byte prop,
-    const CLzma2DecMtProps *props,
-    ISeqOutStream *outStream,
-    const UInt64 *outDataSize, // NULL means undefined
-    int finishMode,            // 0 - partial unpacking is allowed, 1 - if lzma2 stream must be finished
-    // Byte *outBuf, size_t *outBufSize,
-    ISeqInStream *inStream,
-    // const Byte *inData, size_t inDataSize,
-    
-    // out variables:
-    UInt64 *inProcessed,
-    int *isMT,  /* out: (*isMT == 0), if single thread decoding was used */
-
-    // UInt64 *outProcessed,
-    ICompressProgress *progress);
-
-
-/* ---------- Read from CLzma2DecMtHandle Interface ---------- */
-
-SRes Lzma2DecMt_Init(CLzma2DecMtHandle pp,
-    Byte prop,
-    const CLzma2DecMtProps *props,
-    const UInt64 *outDataSize, int finishMode,
-    ISeqInStream *inStream);
-
-SRes Lzma2DecMt_Read(CLzma2DecMtHandle pp,
-    Byte *data, size_t *outSize,
-    UInt64 *inStreamProcessed);
-
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/Lzma2Enc.c

@@ -1,803 +0,0 @@
-/* Lzma2Enc.c -- LZMA2 Encoder
-2021-02-09 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include <string.h>
-
-/* #define _7ZIP_ST */
-
-#include "Lzma2Enc.h"
-
-#ifndef _7ZIP_ST
-#include "MtCoder.h"
-#else
-#define MTCODER__THREADS_MAX 1
-#endif
-
-#define LZMA2_CONTROL_LZMA (1 << 7)
-#define LZMA2_CONTROL_COPY_NO_RESET 2
-#define LZMA2_CONTROL_COPY_RESET_DIC 1
-#define LZMA2_CONTROL_EOF 0
-
-#define LZMA2_LCLP_MAX 4
-
-#define LZMA2_DIC_SIZE_FROM_PROP(p) (((UInt32)2 | ((p) & 1)) << ((p) / 2 + 11))
-
-#define LZMA2_PACK_SIZE_MAX (1 << 16)
-#define LZMA2_COPY_CHUNK_SIZE LZMA2_PACK_SIZE_MAX
-#define LZMA2_UNPACK_SIZE_MAX (1 << 21)
-#define LZMA2_KEEP_WINDOW_SIZE LZMA2_UNPACK_SIZE_MAX
-
-#define LZMA2_CHUNK_SIZE_COMPRESSED_MAX ((1 << 16) + 16)
-
-
-#define PRF(x) /* x */
-
-
-/* ---------- CLimitedSeqInStream ---------- */
-
-typedef struct
-{
-  ISeqInStream vt;
-  ISeqInStream *realStream;
-  UInt64 limit;
-  UInt64 processed;
-  int finished;
-} CLimitedSeqInStream;
-
-static void LimitedSeqInStream_Init(CLimitedSeqInStream *p)
-{
-  p->limit = (UInt64)(Int64)-1;
-  p->processed = 0;
-  p->finished = 0;
-}
-
-static SRes LimitedSeqInStream_Read(const ISeqInStream *pp, void *data, size_t *size)
-{
-  CLimitedSeqInStream *p = CONTAINER_FROM_VTBL(pp, CLimitedSeqInStream, vt);
-  size_t size2 = *size;
-  SRes res = SZ_OK;
-  
-  if (p->limit != (UInt64)(Int64)-1)
-  {
-    UInt64 rem = p->limit - p->processed;
-    if (size2 > rem)
-      size2 = (size_t)rem;
-  }
-  if (size2 != 0)
-  {
-    res = ISeqInStream_Read(p->realStream, data, &size2);
-    p->finished = (size2 == 0 ? 1 : 0);
-    p->processed += size2;
-  }
-  *size = size2;
-  return res;
-}
-
-
-/* ---------- CLzma2EncInt ---------- */
-
-typedef struct
-{
-  CLzmaEncHandle enc;
-  Byte propsAreSet;
-  Byte propsByte;
-  Byte needInitState;
-  Byte needInitProp;
-  UInt64 srcPos;
-} CLzma2EncInt;
-
-
-static SRes Lzma2EncInt_InitStream(CLzma2EncInt *p, const CLzma2EncProps *props)
-{
-  if (!p->propsAreSet)
-  {
-    SizeT propsSize = LZMA_PROPS_SIZE;
-    Byte propsEncoded[LZMA_PROPS_SIZE];
-    RINOK(LzmaEnc_SetProps(p->enc, &props->lzmaProps));
-    RINOK(LzmaEnc_WriteProperties(p->enc, propsEncoded, &propsSize));
-    p->propsByte = propsEncoded[0];
-    p->propsAreSet = True;
-  }
-  return SZ_OK;
-}
-
-static void Lzma2EncInt_InitBlock(CLzma2EncInt *p)
-{
-  p->srcPos = 0;
-  p->needInitState = True;
-  p->needInitProp = True;
-}
-
-
-SRes LzmaEnc_PrepareForLzma2(CLzmaEncHandle pp, ISeqInStream *inStream, UInt32 keepWindowSize,
-    ISzAllocPtr alloc, ISzAllocPtr allocBig);
-SRes LzmaEnc_MemPrepare(CLzmaEncHandle pp, const Byte *src, SizeT srcLen,
-    UInt32 keepWindowSize, ISzAllocPtr alloc, ISzAllocPtr allocBig);
-SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, BoolInt reInit,
-    Byte *dest, size_t *destLen, UInt32 desiredPackSize, UInt32 *unpackSize);
-const Byte *LzmaEnc_GetCurBuf(CLzmaEncHandle pp);
-void LzmaEnc_Finish(CLzmaEncHandle pp);
-void LzmaEnc_SaveState(CLzmaEncHandle pp);
-void LzmaEnc_RestoreState(CLzmaEncHandle pp);
-
-/*
-UInt32 LzmaEnc_GetNumAvailableBytes(CLzmaEncHandle pp);
-*/
-
-static SRes Lzma2EncInt_EncodeSubblock(CLzma2EncInt *p, Byte *outBuf,
-    size_t *packSizeRes, ISeqOutStream *outStream)
-{
-  size_t packSizeLimit = *packSizeRes;
-  size_t packSize = packSizeLimit;
-  UInt32 unpackSize = LZMA2_UNPACK_SIZE_MAX;
-  unsigned lzHeaderSize = 5 + (p->needInitProp ? 1 : 0);
-  BoolInt useCopyBlock;
-  SRes res;
-
-  *packSizeRes = 0;
-  if (packSize < lzHeaderSize)
-    return SZ_ERROR_OUTPUT_EOF;
-  packSize -= lzHeaderSize;
-  
-  LzmaEnc_SaveState(p->enc);
-  res = LzmaEnc_CodeOneMemBlock(p->enc, p->needInitState,
-      outBuf + lzHeaderSize, &packSize, LZMA2_PACK_SIZE_MAX, &unpackSize);
-  
-  PRF(printf("\npackSize = %7d unpackSize = %7d  ", packSize, unpackSize));
-
-  if (unpackSize == 0)
-    return res;
-
-  if (res == SZ_OK)
-    useCopyBlock = (packSize + 2 >= unpackSize || packSize > (1 << 16));
-  else
-  {
-    if (res != SZ_ERROR_OUTPUT_EOF)
-      return res;
-    res = SZ_OK;
-    useCopyBlock = True;
-  }
-
-  if (useCopyBlock)
-  {
-    size_t destPos = 0;
-    PRF(printf("################# COPY           "));
-
-    while (unpackSize > 0)
-    {
-      UInt32 u = (unpackSize < LZMA2_COPY_CHUNK_SIZE) ? unpackSize : LZMA2_COPY_CHUNK_SIZE;
-      if (packSizeLimit - destPos < u + 3)
-        return SZ_ERROR_OUTPUT_EOF;
-      outBuf[destPos++] = (Byte)(p->srcPos == 0 ? LZMA2_CONTROL_COPY_RESET_DIC : LZMA2_CONTROL_COPY_NO_RESET);
-      outBuf[destPos++] = (Byte)((u - 1) >> 8);
-      outBuf[destPos++] = (Byte)(u - 1);
-      memcpy(outBuf + destPos, LzmaEnc_GetCurBuf(p->enc) - unpackSize, u);
-      unpackSize -= u;
-      destPos += u;
-      p->srcPos += u;
-      
-      if (outStream)
-      {
-        *packSizeRes += destPos;
-        if (ISeqOutStream_Write(outStream, outBuf, destPos) != destPos)
-          return SZ_ERROR_WRITE;
-        destPos = 0;
-      }
-      else
-        *packSizeRes = destPos;
-      /* needInitState = True; */
-    }
-    
-    LzmaEnc_RestoreState(p->enc);
-    return SZ_OK;
-  }
-
-  {
-    size_t destPos = 0;
-    UInt32 u = unpackSize - 1;
-    UInt32 pm = (UInt32)(packSize - 1);
-    unsigned mode = (p->srcPos == 0) ? 3 : (p->needInitState ? (p->needInitProp ? 2 : 1) : 0);
-
-    PRF(printf("               "));
-
-    outBuf[destPos++] = (Byte)(LZMA2_CONTROL_LZMA | (mode << 5) | ((u >> 16) & 0x1F));
-    outBuf[destPos++] = (Byte)(u >> 8);
-    outBuf[destPos++] = (Byte)u;
-    outBuf[destPos++] = (Byte)(pm >> 8);
-    outBuf[destPos++] = (Byte)pm;
-    
-    if (p->needInitProp)
-      outBuf[destPos++] = p->propsByte;
-    
-    p->needInitProp = False;
-    p->needInitState = False;
-    destPos += packSize;
-    p->srcPos += unpackSize;
-
-    if (outStream)
-      if (ISeqOutStream_Write(outStream, outBuf, destPos) != destPos)
-        return SZ_ERROR_WRITE;
-    
-    *packSizeRes = destPos;
-    return SZ_OK;
-  }
-}
-
-
-/* ---------- Lzma2 Props ---------- */
-
-void Lzma2EncProps_Init(CLzma2EncProps *p)
-{
-  LzmaEncProps_Init(&p->lzmaProps);
-  p->blockSize = LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO;
-  p->numBlockThreads_Reduced = -1;
-  p->numBlockThreads_Max = -1;
-  p->numTotalThreads = -1;
-}
-
-void Lzma2EncProps_Normalize(CLzma2EncProps *p)
-{
-  UInt64 fileSize;
-  int t1, t1n, t2, t2r, t3;
-  {
-    CLzmaEncProps lzmaProps = p->lzmaProps;
-    LzmaEncProps_Normalize(&lzmaProps);
-    t1n = lzmaProps.numThreads;
-  }
-
-  t1 = p->lzmaProps.numThreads;
-  t2 = p->numBlockThreads_Max;
-  t3 = p->numTotalThreads;
-
-  if (t2 > MTCODER__THREADS_MAX)
-    t2 = MTCODER__THREADS_MAX;
-
-  if (t3 <= 0)
-  {
-    if (t2 <= 0)
-      t2 = 1;
-    t3 = t1n * t2;
-  }
-  else if (t2 <= 0)
-  {
-    t2 = t3 / t1n;
-    if (t2 == 0)
-    {
-      t1 = 1;
-      t2 = t3;
-    }
-    if (t2 > MTCODER__THREADS_MAX)
-      t2 = MTCODER__THREADS_MAX;
-  }
-  else if (t1 <= 0)
-  {
-    t1 = t3 / t2;
-    if (t1 == 0)
-      t1 = 1;
-  }
-  else
-    t3 = t1n * t2;
-
-  p->lzmaProps.numThreads = t1;
-
-  t2r = t2;
-
-  fileSize = p->lzmaProps.reduceSize;
-
-  if (   p->blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID
-      && p->blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO
-      && (p->blockSize < fileSize || fileSize == (UInt64)(Int64)-1))
-    p->lzmaProps.reduceSize = p->blockSize;
-
-  LzmaEncProps_Normalize(&p->lzmaProps);
-
-  p->lzmaProps.reduceSize = fileSize;
-
-  t1 = p->lzmaProps.numThreads;
-
-  if (p->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID)
-  {
-    t2r = t2 = 1;
-    t3 = t1;
-  }
-  else if (p->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO && t2 <= 1)
-  {
-    /* if there is no block multi-threading, we use SOLID block */
-    p->blockSize = LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID;
-  }
-  else
-  {
-    if (p->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO)
-    {
-      const UInt32 kMinSize = (UInt32)1 << 20;
-      const UInt32 kMaxSize = (UInt32)1 << 28;
-      const UInt32 dictSize = p->lzmaProps.dictSize;
-      UInt64 blockSize = (UInt64)dictSize << 2;
-      if (blockSize < kMinSize) blockSize = kMinSize;
-      if (blockSize > kMaxSize) blockSize = kMaxSize;
-      if (blockSize < dictSize) blockSize = dictSize;
-      blockSize += (kMinSize - 1);
-      blockSize &= ~(UInt64)(kMinSize - 1);
-      p->blockSize = blockSize;
-    }
-    
-    if (t2 > 1 && fileSize != (UInt64)(Int64)-1)
-    {
-      UInt64 numBlocks = fileSize / p->blockSize;
-      if (numBlocks * p->blockSize != fileSize)
-        numBlocks++;
-      if (numBlocks < (unsigned)t2)
-      {
-        t2r = (int)numBlocks;
-        if (t2r == 0)
-          t2r = 1;
-        t3 = t1 * t2r;
-      }
-    }
-  }
-  
-  p->numBlockThreads_Max = t2;
-  p->numBlockThreads_Reduced = t2r;
-  p->numTotalThreads = t3;
-}
-
-
-static SRes Progress(ICompressProgress *p, UInt64 inSize, UInt64 outSize)
-{
-  return (p && ICompressProgress_Progress(p, inSize, outSize) != SZ_OK) ? SZ_ERROR_PROGRESS : SZ_OK;
-}
-
-
-/* ---------- Lzma2 ---------- */
-
-typedef struct
-{
-  Byte propEncoded;
-  CLzma2EncProps props;
-  UInt64 expectedDataSize;
-  
-  Byte *tempBufLzma;
-
-  ISzAllocPtr alloc;
-  ISzAllocPtr allocBig;
-
-  CLzma2EncInt coders[MTCODER__THREADS_MAX];
-
-  #ifndef _7ZIP_ST
-  
-  ISeqOutStream *outStream;
-  Byte *outBuf;
-  size_t outBuf_Rem;   /* remainder in outBuf */
-
-  size_t outBufSize;   /* size of allocated outBufs[i] */
-  size_t outBufsDataSizes[MTCODER__BLOCKS_MAX];
-  BoolInt mtCoder_WasConstructed;
-  CMtCoder mtCoder;
-  Byte *outBufs[MTCODER__BLOCKS_MAX];
-
-  #endif
-
-} CLzma2Enc;
-
-
-
-CLzma2EncHandle Lzma2Enc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig)
-{
-  CLzma2Enc *p = (CLzma2Enc *)ISzAlloc_Alloc(alloc, sizeof(CLzma2Enc));
-  if (!p)
-    return NULL;
-  Lzma2EncProps_Init(&p->props);
-  Lzma2EncProps_Normalize(&p->props);
-  p->expectedDataSize = (UInt64)(Int64)-1;
-  p->tempBufLzma = NULL;
-  p->alloc = alloc;
-  p->allocBig = allocBig;
-  {
-    unsigned i;
-    for (i = 0; i < MTCODER__THREADS_MAX; i++)
-      p->coders[i].enc = NULL;
-  }
-  
-  #ifndef _7ZIP_ST
-  p->mtCoder_WasConstructed = False;
-  {
-    unsigned i;
-    for (i = 0; i < MTCODER__BLOCKS_MAX; i++)
-      p->outBufs[i] = NULL;
-    p->outBufSize = 0;
-  }
-  #endif
-
-  return p;
-}
-
-
-#ifndef _7ZIP_ST
-
-static void Lzma2Enc_FreeOutBufs(CLzma2Enc *p)
-{
-  unsigned i;
-  for (i = 0; i < MTCODER__BLOCKS_MAX; i++)
-    if (p->outBufs[i])
-    {
-      ISzAlloc_Free(p->alloc, p->outBufs[i]);
-      p->outBufs[i] = NULL;
-    }
-  p->outBufSize = 0;
-}
-
-#endif
-
-
-void Lzma2Enc_Destroy(CLzma2EncHandle pp)
-{
-  CLzma2Enc *p = (CLzma2Enc *)pp;
-  unsigned i;
-  for (i = 0; i < MTCODER__THREADS_MAX; i++)
-  {
-    CLzma2EncInt *t = &p->coders[i];
-    if (t->enc)
-    {
-      LzmaEnc_Destroy(t->enc, p->alloc, p->allocBig);
-      t->enc = NULL;
-    }
-  }
-
-
-  #ifndef _7ZIP_ST
-  if (p->mtCoder_WasConstructed)
-  {
-    MtCoder_Destruct(&p->mtCoder);
-    p->mtCoder_WasConstructed = False;
-  }
-  Lzma2Enc_FreeOutBufs(p);
-  #endif
-
-  ISzAlloc_Free(p->alloc, p->tempBufLzma);
-  p->tempBufLzma = NULL;
-
-  ISzAlloc_Free(p->alloc, pp);
-}
-
-
-SRes Lzma2Enc_SetProps(CLzma2EncHandle pp, const CLzma2EncProps *props)
-{
-  CLzma2Enc *p = (CLzma2Enc *)pp;
-  CLzmaEncProps lzmaProps = props->lzmaProps;
-  LzmaEncProps_Normalize(&lzmaProps);
-  if (lzmaProps.lc + lzmaProps.lp > LZMA2_LCLP_MAX)
-    return SZ_ERROR_PARAM;
-  p->props = *props;
-  Lzma2EncProps_Normalize(&p->props);
-  return SZ_OK;
-}
-
-
-void Lzma2Enc_SetDataSize(CLzmaEncHandle pp, UInt64 expectedDataSiize)
-{
-  CLzma2Enc *p = (CLzma2Enc *)pp;
-  p->expectedDataSize = expectedDataSiize;
-}
-
-
-Byte Lzma2Enc_WriteProperties(CLzma2EncHandle pp)
-{
-  CLzma2Enc *p = (CLzma2Enc *)pp;
-  unsigned i;
-  UInt32 dicSize = LzmaEncProps_GetDictSize(&p->props.lzmaProps);
-  for (i = 0; i < 40; i++)
-    if (dicSize <= LZMA2_DIC_SIZE_FROM_PROP(i))
-      break;
-  return (Byte)i;
-}
-
-
-static SRes Lzma2Enc_EncodeMt1(
-    CLzma2Enc *me,
-    CLzma2EncInt *p,
-    ISeqOutStream *outStream,
-    Byte *outBuf, size_t *outBufSize,
-    ISeqInStream *inStream,
-    const Byte *inData, size_t inDataSize,
-    int finished,
-    ICompressProgress *progress)
-{
-  UInt64 unpackTotal = 0;
-  UInt64 packTotal = 0;
-  size_t outLim = 0;
-  CLimitedSeqInStream limitedInStream;
-
-  if (outBuf)
-  {
-    outLim = *outBufSize;
-    *outBufSize = 0;
-  }
-
-  if (!p->enc)
-  {
-    p->propsAreSet = False;
-    p->enc = LzmaEnc_Create(me->alloc);
-    if (!p->enc)
-      return SZ_ERROR_MEM;
-  }
-
-  limitedInStream.realStream = inStream;
-  if (inStream)
-  {
-    limitedInStream.vt.Read = LimitedSeqInStream_Read;
-  }
-  
-  if (!outBuf)
-  {
-    // outStream version works only in one thread. So we use CLzma2Enc::tempBufLzma
-    if (!me->tempBufLzma)
-    {
-      me->tempBufLzma = (Byte *)ISzAlloc_Alloc(me->alloc, LZMA2_CHUNK_SIZE_COMPRESSED_MAX);
-      if (!me->tempBufLzma)
-        return SZ_ERROR_MEM;
-    }
-  }
-
-  RINOK(Lzma2EncInt_InitStream(p, &me->props));
-
-  for (;;)
-  {
-    SRes res = SZ_OK;
-    size_t inSizeCur = 0;
-
-    Lzma2EncInt_InitBlock(p);
-    
-    LimitedSeqInStream_Init(&limitedInStream);
-    limitedInStream.limit = me->props.blockSize;
-
-    if (inStream)
-    {
-      UInt64 expected = (UInt64)(Int64)-1;
-      // inStream version works only in one thread. So we use CLzma2Enc::expectedDataSize
-      if (me->expectedDataSize != (UInt64)(Int64)-1
-          && me->expectedDataSize >= unpackTotal)
-        expected = me->expectedDataSize - unpackTotal;
-      if (me->props.blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID
-          && expected > me->props.blockSize)
-        expected = (size_t)me->props.blockSize;
-
-      LzmaEnc_SetDataSize(p->enc, expected);
-
-      RINOK(LzmaEnc_PrepareForLzma2(p->enc,
-          &limitedInStream.vt,
-          LZMA2_KEEP_WINDOW_SIZE,
-          me->alloc,
-          me->allocBig));
-    }
-    else
-    {
-      inSizeCur = inDataSize - (size_t)unpackTotal;
-      if (me->props.blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID
-          && inSizeCur > me->props.blockSize)
-        inSizeCur = (size_t)me->props.blockSize;
-    
-      // LzmaEnc_SetDataSize(p->enc, inSizeCur);
-      
-      RINOK(LzmaEnc_MemPrepare(p->enc,
-          inData + (size_t)unpackTotal, inSizeCur,
-          LZMA2_KEEP_WINDOW_SIZE,
-          me->alloc,
-          me->allocBig));
-    }
-
-    for (;;)
-    {
-      size_t packSize = LZMA2_CHUNK_SIZE_COMPRESSED_MAX;
-      if (outBuf)
-        packSize = outLim - (size_t)packTotal;
-      
-      res = Lzma2EncInt_EncodeSubblock(p,
-          outBuf ? outBuf + (size_t)packTotal : me->tempBufLzma, &packSize,
-          outBuf ? NULL : outStream);
-      
-      if (res != SZ_OK)
-        break;
-
-      packTotal += packSize;
-      if (outBuf)
-        *outBufSize = (size_t)packTotal;
-      
-      res = Progress(progress, unpackTotal + p->srcPos, packTotal);
-      if (res != SZ_OK)
-        break;
-
-      /*
-      if (LzmaEnc_GetNumAvailableBytes(p->enc) == 0)
-        break;
-      */
-
-      if (packSize == 0)
-        break;
-    }
-    
-    LzmaEnc_Finish(p->enc);
-    
-    unpackTotal += p->srcPos;
-    
-    RINOK(res);
-
-    if (p->srcPos != (inStream ? limitedInStream.processed : inSizeCur))
-      return SZ_ERROR_FAIL;
-    
-    if (inStream ? limitedInStream.finished : (unpackTotal == inDataSize))
-    {
-      if (finished)
-      {
-        if (outBuf)
-        {
-          const size_t destPos = *outBufSize;
-          if (destPos >= outLim)
-            return SZ_ERROR_OUTPUT_EOF;
-          outBuf[destPos] = LZMA2_CONTROL_EOF; // 0
-          *outBufSize = destPos + 1;
-        }
-        else
-        {
-          const Byte b = LZMA2_CONTROL_EOF; // 0;
-          if (ISeqOutStream_Write(outStream, &b, 1) != 1)
-            return SZ_ERROR_WRITE;
-        }
-      }
-      return SZ_OK;
-    }
-  }
-}
-
-
-
-#ifndef _7ZIP_ST
-
-static SRes Lzma2Enc_MtCallback_Code(void *pp, unsigned coderIndex, unsigned outBufIndex,
-    const Byte *src, size_t srcSize, int finished)
-{
-  CLzma2Enc *me = (CLzma2Enc *)pp;
-  size_t destSize = me->outBufSize;
-  SRes res;
-  CMtProgressThunk progressThunk;
-
-  Byte *dest = me->outBufs[outBufIndex];
-
-  me->outBufsDataSizes[outBufIndex] = 0;
-
-  if (!dest)
-  {
-    dest = (Byte *)ISzAlloc_Alloc(me->alloc, me->outBufSize);
-    if (!dest)
-      return SZ_ERROR_MEM;
-    me->outBufs[outBufIndex] = dest;
-  }
-
-  MtProgressThunk_CreateVTable(&progressThunk);
-  progressThunk.mtProgress = &me->mtCoder.mtProgress;
-  progressThunk.inSize = 0;
-  progressThunk.outSize = 0;
-
-  res = Lzma2Enc_EncodeMt1(me,
-      &me->coders[coderIndex],
-      NULL, dest, &destSize,
-      NULL, src, srcSize,
-      finished,
-      &progressThunk.vt);
-
-  me->outBufsDataSizes[outBufIndex] = destSize;
-
-  return res;
-}
-
-
-static SRes Lzma2Enc_MtCallback_Write(void *pp, unsigned outBufIndex)
-{
-  CLzma2Enc *me = (CLzma2Enc *)pp;
-  size_t size = me->outBufsDataSizes[outBufIndex];
-  const Byte *data = me->outBufs[outBufIndex];
-  
-  if (me->outStream)
-    return ISeqOutStream_Write(me->outStream, data, size) == size ? SZ_OK : SZ_ERROR_WRITE;
-  
-  if (size > me->outBuf_Rem)
-    return SZ_ERROR_OUTPUT_EOF;
-  memcpy(me->outBuf, data, size);
-  me->outBuf_Rem -= size;
-  me->outBuf += size;
-  return SZ_OK;
-}
-
-#endif
-
-
-
-SRes Lzma2Enc_Encode2(CLzma2EncHandle pp,
-    ISeqOutStream *outStream,
-    Byte *outBuf, size_t *outBufSize,
-    ISeqInStream *inStream,
-    const Byte *inData, size_t inDataSize,
-    ICompressProgress *progress)
-{
-  CLzma2Enc *p = (CLzma2Enc *)pp;
-
-  if (inStream && inData)
-    return SZ_ERROR_PARAM;
-
-  if (outStream && outBuf)
-    return SZ_ERROR_PARAM;
-
-  {
-    unsigned i;
-    for (i = 0; i < MTCODER__THREADS_MAX; i++)
-      p->coders[i].propsAreSet = False;
-  }
-
-  #ifndef _7ZIP_ST
-  
-  if (p->props.numBlockThreads_Reduced > 1)
-  {
-    IMtCoderCallback2 vt;
-
-    if (!p->mtCoder_WasConstructed)
-    {
-      p->mtCoder_WasConstructed = True;
-      MtCoder_Construct(&p->mtCoder);
-    }
-
-    vt.Code = Lzma2Enc_MtCallback_Code;
-    vt.Write = Lzma2Enc_MtCallback_Write;
-
-    p->outStream = outStream;
-    p->outBuf = NULL;
-    p->outBuf_Rem = 0;
-    if (!outStream)
-    {
-      p->outBuf = outBuf;
-      p->outBuf_Rem = *outBufSize;
-      *outBufSize = 0;
-    }
-
-    p->mtCoder.allocBig = p->allocBig;
-    p->mtCoder.progress = progress;
-    p->mtCoder.inStream = inStream;
-    p->mtCoder.inData = inData;
-    p->mtCoder.inDataSize = inDataSize;
-    p->mtCoder.mtCallback = &vt;
-    p->mtCoder.mtCallbackObject = p;
-
-    p->mtCoder.blockSize = (size_t)p->props.blockSize;
-    if (p->mtCoder.blockSize != p->props.blockSize)
-      return SZ_ERROR_PARAM; /* SZ_ERROR_MEM */
-
-    {
-      size_t destBlockSize = p->mtCoder.blockSize + (p->mtCoder.blockSize >> 10) + 16;
-      if (destBlockSize < p->mtCoder.blockSize)
-        return SZ_ERROR_PARAM;
-      if (p->outBufSize != destBlockSize)
-        Lzma2Enc_FreeOutBufs(p);
-      p->outBufSize = destBlockSize;
-    }
-
-    p->mtCoder.numThreadsMax = (unsigned)p->props.numBlockThreads_Max;
-    p->mtCoder.expectedDataSize = p->expectedDataSize;
-    
-    {
-      SRes res = MtCoder_Code(&p->mtCoder);
-      if (!outStream)
-        *outBufSize = (size_t)(p->outBuf - outBuf);
-      return res;
-    }
-  }
-
-  #endif
-
-
-  return Lzma2Enc_EncodeMt1(p,
-      &p->coders[0],
-      outStream, outBuf, outBufSize,
-      inStream, inData, inDataSize,
-      True, /* finished */
-      progress);
-}

3rdparty/7z/src/Lzma2Enc.h

@@ -1,55 +0,0 @@
-/* Lzma2Enc.h -- LZMA2 Encoder
-2017-07-27 : Igor Pavlov : Public domain */
-
-#ifndef __LZMA2_ENC_H
-#define __LZMA2_ENC_H
-
-#include "LzmaEnc.h"
-
-EXTERN_C_BEGIN
-
-#define LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO 0
-#define LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID ((UInt64)(Int64)-1)
-
-typedef struct
-{
-  CLzmaEncProps lzmaProps;
-  UInt64 blockSize;
-  int numBlockThreads_Reduced;
-  int numBlockThreads_Max;
-  int numTotalThreads;
-} CLzma2EncProps;
-
-void Lzma2EncProps_Init(CLzma2EncProps *p);
-void Lzma2EncProps_Normalize(CLzma2EncProps *p);
-
-/* ---------- CLzmaEnc2Handle Interface ---------- */
-
-/* Lzma2Enc_* functions can return the following exit codes:
-SRes:
-  SZ_OK           - OK
-  SZ_ERROR_MEM    - Memory allocation error
-  SZ_ERROR_PARAM  - Incorrect paramater in props
-  SZ_ERROR_WRITE  - ISeqOutStream write callback error
-  SZ_ERROR_OUTPUT_EOF - output buffer overflow - version with (Byte *) output
-  SZ_ERROR_PROGRESS - some break from progress callback
-  SZ_ERROR_THREAD - error in multithreading functions (only for Mt version)
-*/
-
-typedef void * CLzma2EncHandle;
-
-CLzma2EncHandle Lzma2Enc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig);
-void Lzma2Enc_Destroy(CLzma2EncHandle p);
-SRes Lzma2Enc_SetProps(CLzma2EncHandle p, const CLzma2EncProps *props);
-void Lzma2Enc_SetDataSize(CLzma2EncHandle p, UInt64 expectedDataSiize);
-Byte Lzma2Enc_WriteProperties(CLzma2EncHandle p);
-SRes Lzma2Enc_Encode2(CLzma2EncHandle p,
-    ISeqOutStream *outStream,
-    Byte *outBuf, size_t *outBufSize,
-    ISeqInStream *inStream,
-    const Byte *inData, size_t inDataSize,
-    ICompressProgress *progress);
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/Lzma86.h

@@ -1,111 +0,0 @@
-/* Lzma86.h -- LZMA + x86 (BCJ) Filter
-2013-01-18 : Igor Pavlov : Public domain */
-
-#ifndef __LZMA86_H
-#define __LZMA86_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-#define LZMA86_SIZE_OFFSET (1 + 5)
-#define LZMA86_HEADER_SIZE (LZMA86_SIZE_OFFSET + 8)
-
-/*
-It's an example for LZMA + x86 Filter use.
-You can use .lzma86 extension, if you write that stream to file.
-.lzma86 header adds one additional byte to standard .lzma header.
-.lzma86 header (14 bytes):
-  Offset Size  Description
-    0     1    = 0 - no filter, pure LZMA
-               = 1 - x86 filter + LZMA
-    1     1    lc, lp and pb in encoded form
-    2     4    dictSize (little endian)
-    6     8    uncompressed size (little endian)
-
-
-Lzma86_Encode
--------------
-level - compression level: 0 <= level <= 9, the default value for "level" is 5.
-
-dictSize - The dictionary size in bytes. The maximum value is
-        128 MB = (1 << 27) bytes for 32-bit version
-          1 GB = (1 << 30) bytes for 64-bit version
-     The default value is 16 MB = (1 << 24) bytes, for level = 5.
-     It's recommended to use the dictionary that is larger than 4 KB and
-     that can be calculated as (1 << N) or (3 << N) sizes.
-     For better compression ratio dictSize must be >= inSize.
-
-filterMode:
-    SZ_FILTER_NO   - no Filter
-    SZ_FILTER_YES  - x86 Filter
-    SZ_FILTER_AUTO - it tries both alternatives to select best.
-              Encoder will use 2 or 3 passes:
-              2 passes when FILTER_NO provides better compression.
-              3 passes when FILTER_YES provides better compression.
-
-Lzma86Encode allocates Data with MyAlloc functions.
-RAM Requirements for compressing:
-  RamSize = dictionarySize * 11.5 + 6MB + FilterBlockSize
-      filterMode     FilterBlockSize
-     SZ_FILTER_NO         0
-     SZ_FILTER_YES      inSize
-     SZ_FILTER_AUTO     inSize
-
-
-Return code:
-  SZ_OK               - OK
-  SZ_ERROR_MEM        - Memory allocation error
-  SZ_ERROR_PARAM      - Incorrect paramater
-  SZ_ERROR_OUTPUT_EOF - output buffer overflow
-  SZ_ERROR_THREAD     - errors in multithreading functions (only for Mt version)
-*/
-
-enum ESzFilterMode
-{
-  SZ_FILTER_NO,
-  SZ_FILTER_YES,
-  SZ_FILTER_AUTO
-};
-
-SRes Lzma86_Encode(Byte *dest, size_t *destLen, const Byte *src, size_t srcLen,
-    int level, UInt32 dictSize, int filterMode);
-
-
-/*
-Lzma86_GetUnpackSize:
-  In:
-    src      - input data
-    srcLen   - input data size
-  Out:
-    unpackSize - size of uncompressed stream
-  Return code:
-    SZ_OK               - OK
-    SZ_ERROR_INPUT_EOF  - Error in headers
-*/
-
-SRes Lzma86_GetUnpackSize(const Byte *src, SizeT srcLen, UInt64 *unpackSize);
-
-/*
-Lzma86_Decode:
-  In:
-    dest     - output data
-    destLen  - output data size
-    src      - input data
-    srcLen   - input data size
-  Out:
-    destLen  - processed output size
-    srcLen   - processed input size
-  Return code:
-    SZ_OK           - OK
-    SZ_ERROR_DATA  - Data error
-    SZ_ERROR_MEM   - Memory allocation error
-    SZ_ERROR_UNSUPPORTED - unsupported file
-    SZ_ERROR_INPUT_EOF - it needs more bytes in input buffer
-*/
-
-SRes Lzma86_Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen);
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/Lzma86Dec.c

@@ -1,54 +0,0 @@
-/* Lzma86Dec.c -- LZMA + x86 (BCJ) Filter Decoder
-2016-05-16 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "Lzma86.h"
-
-#include "Alloc.h"
-#include "Bra.h"
-#include "LzmaDec.h"
-
-SRes Lzma86_GetUnpackSize(const Byte *src, SizeT srcLen, UInt64 *unpackSize)
-{
-  unsigned i;
-  if (srcLen < LZMA86_HEADER_SIZE)
-    return SZ_ERROR_INPUT_EOF;
-  *unpackSize = 0;
-  for (i = 0; i < sizeof(UInt64); i++)
-    *unpackSize += ((UInt64)src[LZMA86_SIZE_OFFSET + i]) << (8 * i);
-  return SZ_OK;
-}
-
-SRes Lzma86_Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen)
-{
-  SRes res;
-  int useFilter;
-  SizeT inSizePure;
-  ELzmaStatus status;
-
-  if (*srcLen < LZMA86_HEADER_SIZE)
-    return SZ_ERROR_INPUT_EOF;
-
-  useFilter = src[0];
-
-  if (useFilter > 1)
-  {
-    *destLen = 0;
-    return SZ_ERROR_UNSUPPORTED;
-  }
-
-  inSizePure = *srcLen - LZMA86_HEADER_SIZE;
-  res = LzmaDecode(dest, destLen, src + LZMA86_HEADER_SIZE, &inSizePure,
-      src + 1, LZMA_PROPS_SIZE, LZMA_FINISH_ANY, &status, &g_Alloc);
-  *srcLen = inSizePure + LZMA86_HEADER_SIZE;
-  if (res != SZ_OK)
-    return res;
-  if (useFilter == 1)
-  {
-    UInt32 x86State;
-    x86_Convert_Init(x86State);
-    x86_Convert(dest, *destLen, 0, &x86State, 0);
-  }
-  return SZ_OK;
-}

3rdparty/7z/src/Lzma86Enc.c

@@ -1,104 +0,0 @@
-/* Lzma86Enc.c -- LZMA + x86 (BCJ) Filter Encoder
-2018-07-04 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include <string.h>
-
-#include "Lzma86.h"
-
-#include "Alloc.h"
-#include "Bra.h"
-#include "LzmaEnc.h"
-
-int Lzma86_Encode(Byte *dest, size_t *destLen, const Byte *src, size_t srcLen,
-    int level, UInt32 dictSize, int filterMode)
-{
-  size_t outSize2 = *destLen;
-  Byte *filteredStream;
-  BoolInt useFilter;
-  int mainResult = SZ_ERROR_OUTPUT_EOF;
-  CLzmaEncProps props;
-  LzmaEncProps_Init(&props);
-  props.level = level;
-  props.dictSize = dictSize;
-  
-  *destLen = 0;
-  if (outSize2 < LZMA86_HEADER_SIZE)
-    return SZ_ERROR_OUTPUT_EOF;
-
-  {
-    int i;
-    UInt64 t = srcLen;
-    for (i = 0; i < 8; i++, t >>= 8)
-      dest[LZMA86_SIZE_OFFSET + i] = (Byte)t;
-  }
-
-  filteredStream = 0;
-  useFilter = (filterMode != SZ_FILTER_NO);
-  if (useFilter)
-  {
-    if (srcLen != 0)
-    {
-      filteredStream = (Byte *)MyAlloc(srcLen);
-      if (filteredStream == 0)
-        return SZ_ERROR_MEM;
-      memcpy(filteredStream, src, srcLen);
-    }
-    {
-      UInt32 x86State;
-      x86_Convert_Init(x86State);
-      x86_Convert(filteredStream, srcLen, 0, &x86State, 1);
-    }
-  }
-
-  {
-    size_t minSize = 0;
-    BoolInt bestIsFiltered = False;
-
-    /* passes for SZ_FILTER_AUTO:
-        0 - BCJ + LZMA
-        1 - LZMA
-        2 - BCJ + LZMA agaian, if pass 0 (BCJ + LZMA) is better.
-    */
-    int numPasses = (filterMode == SZ_FILTER_AUTO) ? 3 : 1;
-
-    int i;
-    for (i = 0; i < numPasses; i++)
-    {
-      size_t outSizeProcessed = outSize2 - LZMA86_HEADER_SIZE;
-      size_t outPropsSize = 5;
-      SRes curRes;
-      BoolInt curModeIsFiltered = (numPasses > 1 && i == numPasses - 1);
-      if (curModeIsFiltered && !bestIsFiltered)
-        break;
-      if (useFilter && i == 0)
-        curModeIsFiltered = True;
-      
-      curRes = LzmaEncode(dest + LZMA86_HEADER_SIZE, &outSizeProcessed,
-          curModeIsFiltered ? filteredStream : src, srcLen,
-          &props, dest + 1, &outPropsSize, 0,
-          NULL, &g_Alloc, &g_Alloc);
-      
-      if (curRes != SZ_ERROR_OUTPUT_EOF)
-      {
-        if (curRes != SZ_OK)
-        {
-          mainResult = curRes;
-          break;
-        }
-        if (outSizeProcessed <= minSize || mainResult != SZ_OK)
-        {
-          minSize = outSizeProcessed;
-          bestIsFiltered = curModeIsFiltered;
-          mainResult = SZ_OK;
-        }
-      }
-    }
-    dest[0] = (Byte)(bestIsFiltered ? 1 : 0);
-    *destLen = LZMA86_HEADER_SIZE + minSize;
-  }
-  if (useFilter)
-    MyFree(filteredStream);
-  return mainResult;
-}

3rdparty/7z/src/LzmaDec.h

@@ -1,236 +0,0 @@
-/* LzmaDec.h -- LZMA Decoder
-2020-03-19 : Igor Pavlov : Public domain */
-
-#ifndef __LZMA_DEC_H
-#define __LZMA_DEC_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-/* #define _LZMA_PROB32 */
-/* _LZMA_PROB32 can increase the speed on some CPUs,
-   but memory usage for CLzmaDec::probs will be doubled in that case */
-
-typedef
-#ifdef _LZMA_PROB32
-  UInt32
-#else
-  UInt16
-#endif
-  CLzmaProb;
-
-
-/* ---------- LZMA Properties ---------- */
-
-#define LZMA_PROPS_SIZE 5
-
-typedef struct _CLzmaProps
-{
-  Byte lc;
-  Byte lp;
-  Byte pb;
-  Byte _pad_;
-  UInt32 dicSize;
-} CLzmaProps;
-
-/* LzmaProps_Decode - decodes properties
-Returns:
-  SZ_OK
-  SZ_ERROR_UNSUPPORTED - Unsupported properties
-*/
-
-SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size);
-
-
-/* ---------- LZMA Decoder state ---------- */
-
-/* LZMA_REQUIRED_INPUT_MAX = number of required input bytes for worst case.
-   Num bits = log2((2^11 / 31) ^ 22) + 26 < 134 + 26 = 160; */
-
-#define LZMA_REQUIRED_INPUT_MAX 20
-
-typedef struct
-{
-  /* Don't change this structure. ASM code can use it. */
-  CLzmaProps prop;
-  CLzmaProb *probs;
-  CLzmaProb *probs_1664;
-  Byte *dic;
-  SizeT dicBufSize;
-  SizeT dicPos;
-  const Byte *buf;
-  UInt32 range;
-  UInt32 code;
-  UInt32 processedPos;
-  UInt32 checkDicSize;
-  UInt32 reps[4];
-  UInt32 state;
-  UInt32 remainLen;
-
-  UInt32 numProbs;
-  unsigned tempBufSize;
-  Byte tempBuf[LZMA_REQUIRED_INPUT_MAX];
-} CLzmaDec;
-
-#define LzmaDec_Construct(p) { (p)->dic = NULL; (p)->probs = NULL; }
-
-void LzmaDec_Init(CLzmaDec *p);
-
-/* There are two types of LZMA streams:
-     - Stream with end mark. That end mark adds about 6 bytes to compressed size.
-     - Stream without end mark. You must know exact uncompressed size to decompress such stream. */
-
-typedef enum
-{
-  LZMA_FINISH_ANY,   /* finish at any point */
-  LZMA_FINISH_END    /* block must be finished at the end */
-} ELzmaFinishMode;
-
-/* ELzmaFinishMode has meaning only if the decoding reaches output limit !!!
-
-   You must use LZMA_FINISH_END, when you know that current output buffer
-   covers last bytes of block. In other cases you must use LZMA_FINISH_ANY.
-
-   If LZMA decoder sees end marker before reaching output limit, it returns SZ_OK,
-   and output value of destLen will be less than output buffer size limit.
-   You can check status result also.
-
-   You can use multiple checks to test data integrity after full decompression:
-     1) Check Result and "status" variable.
-     2) Check that output(destLen) = uncompressedSize, if you know real uncompressedSize.
-     3) Check that output(srcLen) = compressedSize, if you know real compressedSize.
-        You must use correct finish mode in that case. */
-
-typedef enum
-{
-  LZMA_STATUS_NOT_SPECIFIED,               /* use main error code instead */
-  LZMA_STATUS_FINISHED_WITH_MARK,          /* stream was finished with end mark. */
-  LZMA_STATUS_NOT_FINISHED,                /* stream was not finished */
-  LZMA_STATUS_NEEDS_MORE_INPUT,            /* you must provide more input bytes */
-  LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK  /* there is probability that stream was finished without end mark */
-} ELzmaStatus;
-
-/* ELzmaStatus is used only as output value for function call */
-
-
-/* ---------- Interfaces ---------- */
-
-/* There are 3 levels of interfaces:
-     1) Dictionary Interface
-     2) Buffer Interface
-     3) One Call Interface
-   You can select any of these interfaces, but don't mix functions from different
-   groups for same object. */
-
-
-/* There are two variants to allocate state for Dictionary Interface:
-     1) LzmaDec_Allocate / LzmaDec_Free
-     2) LzmaDec_AllocateProbs / LzmaDec_FreeProbs
-   You can use variant 2, if you set dictionary buffer manually.
-   For Buffer Interface you must always use variant 1.
-
-LzmaDec_Allocate* can return:
-  SZ_OK
-  SZ_ERROR_MEM         - Memory allocation error
-  SZ_ERROR_UNSUPPORTED - Unsupported properties
-*/
-   
-SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc);
-void LzmaDec_FreeProbs(CLzmaDec *p, ISzAllocPtr alloc);
-
-SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc);
-void LzmaDec_Free(CLzmaDec *p, ISzAllocPtr alloc);
-
-/* ---------- Dictionary Interface ---------- */
-
-/* You can use it, if you want to eliminate the overhead for data copying from
-   dictionary to some other external buffer.
-   You must work with CLzmaDec variables directly in this interface.
-
-   STEPS:
-     LzmaDec_Construct()
-     LzmaDec_Allocate()
-     for (each new stream)
-     {
-       LzmaDec_Init()
-       while (it needs more decompression)
-       {
-         LzmaDec_DecodeToDic()
-         use data from CLzmaDec::dic and update CLzmaDec::dicPos
-       }
-     }
-     LzmaDec_Free()
-*/
-
-/* LzmaDec_DecodeToDic
-   
-   The decoding to internal dictionary buffer (CLzmaDec::dic).
-   You must manually update CLzmaDec::dicPos, if it reaches CLzmaDec::dicBufSize !!!
-
-finishMode:
-  It has meaning only if the decoding reaches output limit (dicLimit).
-  LZMA_FINISH_ANY - Decode just dicLimit bytes.
-  LZMA_FINISH_END - Stream must be finished after dicLimit.
-
-Returns:
-  SZ_OK
-    status:
-      LZMA_STATUS_FINISHED_WITH_MARK
-      LZMA_STATUS_NOT_FINISHED
-      LZMA_STATUS_NEEDS_MORE_INPUT
-      LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK
-  SZ_ERROR_DATA - Data error
-  SZ_ERROR_FAIL - Some unexpected error: internal error of code, memory corruption or hardware failure
-*/
-
-SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit,
-    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
-
-
-/* ---------- Buffer Interface ---------- */
-
-/* It's zlib-like interface.
-   See LzmaDec_DecodeToDic description for information about STEPS and return results,
-   but you must use LzmaDec_DecodeToBuf instead of LzmaDec_DecodeToDic and you don't need
-   to work with CLzmaDec variables manually.
-
-finishMode:
-  It has meaning only if the decoding reaches output limit (*destLen).
-  LZMA_FINISH_ANY - Decode just destLen bytes.
-  LZMA_FINISH_END - Stream must be finished after (*destLen).
-*/
-
-SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen,
-    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
-
-
-/* ---------- One Call Interface ---------- */
-
-/* LzmaDecode
-
-finishMode:
-  It has meaning only if the decoding reaches output limit (*destLen).
-  LZMA_FINISH_ANY - Decode just destLen bytes.
-  LZMA_FINISH_END - Stream must be finished after (*destLen).
-
-Returns:
-  SZ_OK
-    status:
-      LZMA_STATUS_FINISHED_WITH_MARK
-      LZMA_STATUS_NOT_FINISHED
-      LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK
-  SZ_ERROR_DATA - Data error
-  SZ_ERROR_MEM  - Memory allocation error
-  SZ_ERROR_UNSUPPORTED - Unsupported properties
-  SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).
-  SZ_ERROR_FAIL - Some unexpected error: internal error of code, memory corruption or hardware failure
-*/
-
-SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
-    const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,
-    ELzmaStatus *status, ISzAllocPtr alloc);
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/LzmaEnc.h

@@ -1,78 +0,0 @@
-/*  LzmaEnc.h -- LZMA Encoder
-2019-10-30 : Igor Pavlov : Public domain */
-
-#ifndef __LZMA_ENC_H
-#define __LZMA_ENC_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-#define LZMA_PROPS_SIZE 5
-
-typedef struct _CLzmaEncProps
-{
-  int level;       /* 0 <= level <= 9 */
-  UInt32 dictSize; /* (1 << 12) <= dictSize <= (1 << 27) for 32-bit version
-                      (1 << 12) <= dictSize <= (3 << 29) for 64-bit version
-                      default = (1 << 24) */
-  int lc;          /* 0 <= lc <= 8, default = 3 */
-  int lp;          /* 0 <= lp <= 4, default = 0 */
-  int pb;          /* 0 <= pb <= 4, default = 2 */
-  int algo;        /* 0 - fast, 1 - normal, default = 1 */
-  int fb;          /* 5 <= fb <= 273, default = 32 */
-  int btMode;      /* 0 - hashChain Mode, 1 - binTree mode - normal, default = 1 */
-  int numHashBytes; /* 2, 3 or 4, default = 4 */
-  UInt32 mc;       /* 1 <= mc <= (1 << 30), default = 32 */
-  unsigned writeEndMark;  /* 0 - do not write EOPM, 1 - write EOPM, default = 0 */
-  int numThreads;  /* 1 or 2, default = 2 */
-
-  UInt64 reduceSize; /* estimated size of data that will be compressed. default = (UInt64)(Int64)-1.
-                        Encoder uses this value to reduce dictionary size */
-
-  UInt64 affinity;
-} CLzmaEncProps;
-
-void LzmaEncProps_Init(CLzmaEncProps *p);
-void LzmaEncProps_Normalize(CLzmaEncProps *p);
-UInt32 LzmaEncProps_GetDictSize(const CLzmaEncProps *props2);
-
-
-/* ---------- CLzmaEncHandle Interface ---------- */
-
-/* LzmaEnc* functions can return the following exit codes:
-SRes:
-  SZ_OK           - OK
-  SZ_ERROR_MEM    - Memory allocation error
-  SZ_ERROR_PARAM  - Incorrect paramater in props
-  SZ_ERROR_WRITE  - ISeqOutStream write callback error
-  SZ_ERROR_OUTPUT_EOF - output buffer overflow - version with (Byte *) output
-  SZ_ERROR_PROGRESS - some break from progress callback
-  SZ_ERROR_THREAD - error in multithreading functions (only for Mt version)
-*/
-
-typedef void * CLzmaEncHandle;
-
-CLzmaEncHandle LzmaEnc_Create(ISzAllocPtr alloc);
-void LzmaEnc_Destroy(CLzmaEncHandle p, ISzAllocPtr alloc, ISzAllocPtr allocBig);
-
-SRes LzmaEnc_SetProps(CLzmaEncHandle p, const CLzmaEncProps *props);
-void LzmaEnc_SetDataSize(CLzmaEncHandle p, UInt64 expectedDataSiize);
-SRes LzmaEnc_WriteProperties(CLzmaEncHandle p, Byte *properties, SizeT *size);
-unsigned LzmaEnc_IsWriteEndMark(CLzmaEncHandle p);
-
-SRes LzmaEnc_Encode(CLzmaEncHandle p, ISeqOutStream *outStream, ISeqInStream *inStream,
-    ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
-SRes LzmaEnc_MemEncode(CLzmaEncHandle p, Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
-    int writeEndMark, ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
-
-
-/* ---------- One Call Interface ---------- */
-
-SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
-    const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,
-    ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/LzmaLib.c

@@ -1,40 +0,0 @@
-/* LzmaLib.c -- LZMA library wrapper
-2015-06-13 : Igor Pavlov : Public domain */
-
-#include "Alloc.h"
-#include "LzmaDec.h"
-#include "LzmaEnc.h"
-#include "LzmaLib.h"
-
-MY_STDAPI LzmaCompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t srcLen,
-  unsigned char *outProps, size_t *outPropsSize,
-  int level, /* 0 <= level <= 9, default = 5 */
-  unsigned dictSize, /* use (1 << N) or (3 << N). 4 KB < dictSize <= 128 MB */
-  int lc, /* 0 <= lc <= 8, default = 3  */
-  int lp, /* 0 <= lp <= 4, default = 0  */
-  int pb, /* 0 <= pb <= 4, default = 2  */
-  int fb,  /* 5 <= fb <= 273, default = 32 */
-  int numThreads /* 1 or 2, default = 2 */
-)
-{
-  CLzmaEncProps props;
-  LzmaEncProps_Init(&props);
-  props.level = level;
-  props.dictSize = dictSize;
-  props.lc = lc;
-  props.lp = lp;
-  props.pb = pb;
-  props.fb = fb;
-  props.numThreads = numThreads;
-
-  return LzmaEncode(dest, destLen, src, srcLen, &props, outProps, outPropsSize, 0,
-      NULL, &g_Alloc, &g_Alloc);
-}
-
-
-MY_STDAPI LzmaUncompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t *srcLen,
-  const unsigned char *props, size_t propsSize)
-{
-  ELzmaStatus status;
-  return LzmaDecode(dest, destLen, src, srcLen, props, (unsigned)propsSize, LZMA_FINISH_ANY, &status, &g_Alloc);
-}

3rdparty/7z/src/LzmaLib.h

@@ -1,138 +0,0 @@
-/* LzmaLib.h -- LZMA library interface
-2021-04-03 : Igor Pavlov : Public domain */
-
-#ifndef __LZMA_LIB_H
-#define __LZMA_LIB_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-#define MY_STDAPI int MY_STD_CALL
-
-#define LZMA_PROPS_SIZE 5
-
-/*
-RAM requirements for LZMA:
-  for compression:   (dictSize * 11.5 + 6 MB) + state_size
-  for decompression: dictSize + state_size
-    state_size = (4 + (1.5 << (lc + lp))) KB
-    by default (lc=3, lp=0), state_size = 16 KB.
-
-LZMA properties (5 bytes) format
-    Offset Size  Description
-      0     1    lc, lp and pb in encoded form.
-      1     4    dictSize (little endian).
-*/
-
-/*
-LzmaCompress
-------------
-
-outPropsSize -
-     In:  the pointer to the size of outProps buffer; *outPropsSize = LZMA_PROPS_SIZE = 5.
-     Out: the pointer to the size of written properties in outProps buffer; *outPropsSize = LZMA_PROPS_SIZE = 5.
-
-  LZMA Encoder will use defult values for any parameter, if it is
-  -1  for any from: level, loc, lp, pb, fb, numThreads
-   0  for dictSize
-  
-level - compression level: 0 <= level <= 9;
-
-  level dictSize algo  fb
-    0:    64 KB   0    32
-    1:   256 KB   0    32
-    2:     1 MB   0    32
-    3:     4 MB   0    32
-    4:    16 MB   0    32
-    5:    16 MB   1    32
-    6:    32 MB   1    32
-    7:    32 MB   1    64
-    8:    64 MB   1    64
-    9:    64 MB   1    64
- 
-  The default value for "level" is 5.
-
-  algo = 0 means fast method
-  algo = 1 means normal method
-
-dictSize - The dictionary size in bytes. The maximum value is
-        128 MB = (1 << 27) bytes for 32-bit version
-          1 GB = (1 << 30) bytes for 64-bit version
-     The default value is 16 MB = (1 << 24) bytes.
-     It's recommended to use the dictionary that is larger than 4 KB and
-     that can be calculated as (1 << N) or (3 << N) sizes.
-
-lc - The number of literal context bits (high bits of previous literal).
-     It can be in the range from 0 to 8. The default value is 3.
-     Sometimes lc=4 gives the gain for big files.
-
-lp - The number of literal pos bits (low bits of current position for literals).
-     It can be in the range from 0 to 4. The default value is 0.
-     The lp switch is intended for periodical data when the period is equal to 2^lp.
-     For example, for 32-bit (4 bytes) periodical data you can use lp=2. Often it's
-     better to set lc=0, if you change lp switch.
-
-pb - The number of pos bits (low bits of current position).
-     It can be in the range from 0 to 4. The default value is 2.
-     The pb switch is intended for periodical data when the period is equal 2^pb.
-
-fb - Word size (the number of fast bytes).
-     It can be in the range from 5 to 273. The default value is 32.
-     Usually, a big number gives a little bit better compression ratio and
-     slower compression process.
-
-numThreads - The number of thereads. 1 or 2. The default value is 2.
-     Fast mode (algo = 0) can use only 1 thread.
-
-In:
-  dest     - output data buffer
-  destLen  - output data buffer size
-  src      - input data
-  srcLen   - input data size
-Out:
-  destLen  - processed output size
-Returns:
-  SZ_OK               - OK
-  SZ_ERROR_MEM        - Memory allocation error
-  SZ_ERROR_PARAM      - Incorrect paramater
-  SZ_ERROR_OUTPUT_EOF - output buffer overflow
-  SZ_ERROR_THREAD     - errors in multithreading functions (only for Mt version)
-*/
-
-MY_STDAPI LzmaCompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t srcLen,
-  unsigned char *outProps, size_t *outPropsSize, /* *outPropsSize must be = 5 */
-  int level,      /* 0 <= level <= 9, default = 5 */
-  unsigned dictSize,  /* default = (1 << 24) */
-  int lc,        /* 0 <= lc <= 8, default = 3  */
-  int lp,        /* 0 <= lp <= 4, default = 0  */
-  int pb,        /* 0 <= pb <= 4, default = 2  */
-  int fb,        /* 5 <= fb <= 273, default = 32 */
-  int numThreads /* 1 or 2, default = 2 */
-  );
-
-/*
-LzmaUncompress
---------------
-In:
-  dest     - output data buffer
-  destLen  - output data buffer size
-  src      - input data
-  srcLen   - input data size
-Out:
-  destLen  - processed output size
-  srcLen   - processed input size
-Returns:
-  SZ_OK                - OK
-  SZ_ERROR_DATA        - Data error
-  SZ_ERROR_MEM         - Memory allocation arror
-  SZ_ERROR_UNSUPPORTED - Unsupported properties
-  SZ_ERROR_INPUT_EOF   - it needs more bytes in input buffer (src)
-*/
-
-MY_STDAPI LzmaUncompress(unsigned char *dest, size_t *destLen, const unsigned char *src, SizeT *srcLen,
-  const unsigned char *props, size_t propsSize);
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/MtCoder.c

@@ -1,595 +0,0 @@
-/* MtCoder.c -- Multi-thread Coder
-2021-12-21 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "MtCoder.h"
-
-#ifndef _7ZIP_ST
-
-static SRes MtProgressThunk_Progress(const ICompressProgress *pp, UInt64 inSize, UInt64 outSize)
-{
-  CMtProgressThunk *thunk = CONTAINER_FROM_VTBL(pp, CMtProgressThunk, vt);
-  UInt64 inSize2 = 0;
-  UInt64 outSize2 = 0;
-  if (inSize != (UInt64)(Int64)-1)
-  {
-    inSize2 = inSize - thunk->inSize;
-    thunk->inSize = inSize;
-  }
-  if (outSize != (UInt64)(Int64)-1)
-  {
-    outSize2 = outSize - thunk->outSize;
-    thunk->outSize = outSize;
-  }
-  return MtProgress_ProgressAdd(thunk->mtProgress, inSize2, outSize2);
-}
-
-
-void MtProgressThunk_CreateVTable(CMtProgressThunk *p)
-{
-  p->vt.Progress = MtProgressThunk_Progress;
-}
-
-
-
-#define RINOK_THREAD(x) { if ((x) != 0) return SZ_ERROR_THREAD; }
-
-
-static WRes ArEvent_OptCreate_And_Reset(CEvent *p)
-{
-  if (Event_IsCreated(p))
-    return Event_Reset(p);
-  return AutoResetEvent_CreateNotSignaled(p);
-}
-
-
-static THREAD_FUNC_DECL ThreadFunc(void *pp);
-
-
-static SRes MtCoderThread_CreateAndStart(CMtCoderThread *t)
-{
-  WRes wres = ArEvent_OptCreate_And_Reset(&t->startEvent);
-  if (wres == 0)
-  {
-    t->stop = False;
-    if (!Thread_WasCreated(&t->thread))
-      wres = Thread_Create(&t->thread, ThreadFunc, t);
-    if (wres == 0)
-      wres = Event_Set(&t->startEvent);
-  }
-  if (wres == 0)
-    return SZ_OK;
-  return MY_SRes_HRESULT_FROM_WRes(wres);
-}
-
-
-static void MtCoderThread_Destruct(CMtCoderThread *t)
-{
-  if (Thread_WasCreated(&t->thread))
-  {
-    t->stop = 1;
-    Event_Set(&t->startEvent);
-    Thread_Wait_Close(&t->thread);
-  }
-
-  Event_Close(&t->startEvent);
-
-  if (t->inBuf)
-  {
-    ISzAlloc_Free(t->mtCoder->allocBig, t->inBuf);
-    t->inBuf = NULL;
-  }
-}
-
-
-
-static SRes FullRead(ISeqInStream *stream, Byte *data, size_t *processedSize)
-{
-  size_t size = *processedSize;
-  *processedSize = 0;
-  while (size != 0)
-  {
-    size_t cur = size;
-    SRes res = ISeqInStream_Read(stream, data, &cur);
-    *processedSize += cur;
-    data += cur;
-    size -= cur;
-    RINOK(res);
-    if (cur == 0)
-      return SZ_OK;
-  }
-  return SZ_OK;
-}
-
-
-/*
-  ThreadFunc2() returns:
-  SZ_OK           - in all normal cases (even for stream error or memory allocation error)
-  SZ_ERROR_THREAD - in case of failure in system synch function
-*/
-
-static SRes ThreadFunc2(CMtCoderThread *t)
-{
-  CMtCoder *mtc = t->mtCoder;
-
-  for (;;)
-  {
-    unsigned bi;
-    SRes res;
-    SRes res2;
-    BoolInt finished;
-    unsigned bufIndex;
-    size_t size;
-    const Byte *inData;
-    UInt64 readProcessed = 0;
-    
-    RINOK_THREAD(Event_Wait(&mtc->readEvent))
-
-    /* after Event_Wait(&mtc->readEvent) we must call Event_Set(&mtc->readEvent) in any case to unlock another threads */
-
-    if (mtc->stopReading)
-    {
-      return Event_Set(&mtc->readEvent) == 0 ? SZ_OK : SZ_ERROR_THREAD;
-    }
-
-    res = MtProgress_GetError(&mtc->mtProgress);
-    
-    size = 0;
-    inData = NULL;
-    finished = True;
-
-    if (res == SZ_OK)
-    {
-      size = mtc->blockSize;
-      if (mtc->inStream)
-      {
-        if (!t->inBuf)
-        {
-          t->inBuf = (Byte *)ISzAlloc_Alloc(mtc->allocBig, mtc->blockSize);
-          if (!t->inBuf)
-            res = SZ_ERROR_MEM;
-        }
-        if (res == SZ_OK)
-        {
-          res = FullRead(mtc->inStream, t->inBuf, &size);
-          readProcessed = mtc->readProcessed + size;
-          mtc->readProcessed = readProcessed;
-        }
-        if (res != SZ_OK)
-        {
-          mtc->readRes = res;
-          /* after reading error - we can stop encoding of previous blocks */
-          MtProgress_SetError(&mtc->mtProgress, res);
-        }
-        else
-          finished = (size != mtc->blockSize);
-      }
-      else
-      {
-        size_t rem;
-        readProcessed = mtc->readProcessed;
-        rem = mtc->inDataSize - (size_t)readProcessed;
-        if (size > rem)
-          size = rem;
-        inData = mtc->inData + (size_t)readProcessed;
-        readProcessed += size;
-        mtc->readProcessed = readProcessed;
-        finished = (mtc->inDataSize == (size_t)readProcessed);
-      }
-    }
-
-    /* we must get some block from blocksSemaphore before Event_Set(&mtc->readEvent) */
-
-    res2 = SZ_OK;
-
-    if (Semaphore_Wait(&mtc->blocksSemaphore) != 0)
-    {
-      res2 = SZ_ERROR_THREAD;
-      if (res == SZ_OK)
-      {
-        res = res2;
-        // MtProgress_SetError(&mtc->mtProgress, res);
-      }
-    }
-
-    bi = mtc->blockIndex;
-
-    if (++mtc->blockIndex >= mtc->numBlocksMax)
-      mtc->blockIndex = 0;
-
-    bufIndex = (unsigned)(int)-1;
-
-    if (res == SZ_OK)
-      res = MtProgress_GetError(&mtc->mtProgress);
-
-    if (res != SZ_OK)
-      finished = True;
-
-    if (!finished)
-    {
-      if (mtc->numStartedThreads < mtc->numStartedThreadsLimit
-          && mtc->expectedDataSize != readProcessed)
-      {
-        res = MtCoderThread_CreateAndStart(&mtc->threads[mtc->numStartedThreads]);
-        if (res == SZ_OK)
-          mtc->numStartedThreads++;
-        else
-        {
-          MtProgress_SetError(&mtc->mtProgress, res);
-          finished = True;
-        }
-      }
-    }
-
-    if (finished)
-      mtc->stopReading = True;
-
-    RINOK_THREAD(Event_Set(&mtc->readEvent))
-
-    if (res2 != SZ_OK)
-      return res2;
-
-    if (res == SZ_OK)
-    {
-      CriticalSection_Enter(&mtc->cs);
-      bufIndex = mtc->freeBlockHead;
-      mtc->freeBlockHead = mtc->freeBlockList[bufIndex];
-      CriticalSection_Leave(&mtc->cs);
-      
-      res = mtc->mtCallback->Code(mtc->mtCallbackObject, t->index, bufIndex,
-          mtc->inStream ? t->inBuf : inData, size, finished);
-      
-      // MtProgress_Reinit(&mtc->mtProgress, t->index);
-
-      if (res != SZ_OK)
-        MtProgress_SetError(&mtc->mtProgress, res);
-    }
-
-    {
-      CMtCoderBlock *block = &mtc->blocks[bi];
-      block->res = res;
-      block->bufIndex = bufIndex;
-      block->finished = finished;
-    }
-    
-    #ifdef MTCODER__USE_WRITE_THREAD
-      RINOK_THREAD(Event_Set(&mtc->writeEvents[bi]))
-    #else
-    {
-      unsigned wi;
-      {
-        CriticalSection_Enter(&mtc->cs);
-        wi = mtc->writeIndex;
-        if (wi == bi)
-          mtc->writeIndex = (unsigned)(int)-1;
-        else
-          mtc->ReadyBlocks[bi] = True;
-        CriticalSection_Leave(&mtc->cs);
-      }
-
-      if (wi != bi)
-      {
-        if (res != SZ_OK || finished)
-          return 0;
-        continue;
-      }
-
-      if (mtc->writeRes != SZ_OK)
-        res = mtc->writeRes;
-
-      for (;;)
-      {
-        if (res == SZ_OK && bufIndex != (unsigned)(int)-1)
-        {
-          res = mtc->mtCallback->Write(mtc->mtCallbackObject, bufIndex);
-          if (res != SZ_OK)
-          {
-            mtc->writeRes = res;
-            MtProgress_SetError(&mtc->mtProgress, res);
-          }
-        }
-
-        if (++wi >= mtc->numBlocksMax)
-          wi = 0;
-        {
-          BoolInt isReady;
-
-          CriticalSection_Enter(&mtc->cs);
-          
-          if (bufIndex != (unsigned)(int)-1)
-          {
-            mtc->freeBlockList[bufIndex] = mtc->freeBlockHead;
-            mtc->freeBlockHead = bufIndex;
-          }
-          
-          isReady = mtc->ReadyBlocks[wi];
-          
-          if (isReady)
-            mtc->ReadyBlocks[wi] = False;
-          else
-            mtc->writeIndex = wi;
-          
-          CriticalSection_Leave(&mtc->cs);
-
-          RINOK_THREAD(Semaphore_Release1(&mtc->blocksSemaphore))
-
-          if (!isReady)
-            break;
-        }
-
-        {
-          CMtCoderBlock *block = &mtc->blocks[wi];
-          if (res == SZ_OK && block->res != SZ_OK)
-            res = block->res;
-          bufIndex = block->bufIndex;
-          finished = block->finished;
-        }
-      }
-    }
-    #endif
-      
-    if (finished || res != SZ_OK)
-      return 0;
-  }
-}
-
-
-static THREAD_FUNC_DECL ThreadFunc(void *pp)
-{
-  CMtCoderThread *t = (CMtCoderThread *)pp;
-  for (;;)
-  {
-    if (Event_Wait(&t->startEvent) != 0)
-      return (THREAD_FUNC_RET_TYPE)SZ_ERROR_THREAD;
-    if (t->stop)
-      return 0;
-    {
-      SRes res = ThreadFunc2(t);
-      CMtCoder *mtc = t->mtCoder;
-      if (res != SZ_OK)
-      {
-        MtProgress_SetError(&mtc->mtProgress, res);
-      }
-      
-      #ifndef MTCODER__USE_WRITE_THREAD
-      {
-        unsigned numFinished = (unsigned)InterlockedIncrement(&mtc->numFinishedThreads);
-        if (numFinished == mtc->numStartedThreads)
-          if (Event_Set(&mtc->finishedEvent) != 0)
-            return (THREAD_FUNC_RET_TYPE)SZ_ERROR_THREAD;
-      }
-      #endif
-    }
-  }
-}
-
-
-
-void MtCoder_Construct(CMtCoder *p)
-{
-  unsigned i;
-  
-  p->blockSize = 0;
-  p->numThreadsMax = 0;
-  p->expectedDataSize = (UInt64)(Int64)-1;
-
-  p->inStream = NULL;
-  p->inData = NULL;
-  p->inDataSize = 0;
-
-  p->progress = NULL;
-  p->allocBig = NULL;
-
-  p->mtCallback = NULL;
-  p->mtCallbackObject = NULL;
-
-  p->allocatedBufsSize = 0;
-
-  Event_Construct(&p->readEvent);
-  Semaphore_Construct(&p->blocksSemaphore);
-
-  for (i = 0; i < MTCODER__THREADS_MAX; i++)
-  {
-    CMtCoderThread *t = &p->threads[i];
-    t->mtCoder = p;
-    t->index = i;
-    t->inBuf = NULL;
-    t->stop = False;
-    Event_Construct(&t->startEvent);
-    Thread_Construct(&t->thread);
-  }
-
-  #ifdef MTCODER__USE_WRITE_THREAD
-    for (i = 0; i < MTCODER__BLOCKS_MAX; i++)
-      Event_Construct(&p->writeEvents[i]);
-  #else
-    Event_Construct(&p->finishedEvent);
-  #endif
-
-  CriticalSection_Init(&p->cs);
-  CriticalSection_Init(&p->mtProgress.cs);
-}
-
-
-
-
-static void MtCoder_Free(CMtCoder *p)
-{
-  unsigned i;
-
-  /*
-  p->stopReading = True;
-  if (Event_IsCreated(&p->readEvent))
-    Event_Set(&p->readEvent);
-  */
-
-  for (i = 0; i < MTCODER__THREADS_MAX; i++)
-    MtCoderThread_Destruct(&p->threads[i]);
-
-  Event_Close(&p->readEvent);
-  Semaphore_Close(&p->blocksSemaphore);
-
-  #ifdef MTCODER__USE_WRITE_THREAD
-    for (i = 0; i < MTCODER__BLOCKS_MAX; i++)
-      Event_Close(&p->writeEvents[i]);
-  #else
-    Event_Close(&p->finishedEvent);
-  #endif
-}
-
-
-void MtCoder_Destruct(CMtCoder *p)
-{
-  MtCoder_Free(p);
-
-  CriticalSection_Delete(&p->cs);
-  CriticalSection_Delete(&p->mtProgress.cs);
-}
-
-
-SRes MtCoder_Code(CMtCoder *p)
-{
-  unsigned numThreads = p->numThreadsMax;
-  unsigned numBlocksMax;
-  unsigned i;
-  SRes res = SZ_OK;
-
-  if (numThreads > MTCODER__THREADS_MAX)
-    numThreads = MTCODER__THREADS_MAX;
-  numBlocksMax = MTCODER__GET_NUM_BLOCKS_FROM_THREADS(numThreads);
-  
-  if (p->blockSize < ((UInt32)1 << 26)) numBlocksMax++;
-  if (p->blockSize < ((UInt32)1 << 24)) numBlocksMax++;
-  if (p->blockSize < ((UInt32)1 << 22)) numBlocksMax++;
-
-  if (numBlocksMax > MTCODER__BLOCKS_MAX)
-    numBlocksMax = MTCODER__BLOCKS_MAX;
-
-  if (p->blockSize != p->allocatedBufsSize)
-  {
-    for (i = 0; i < MTCODER__THREADS_MAX; i++)
-    {
-      CMtCoderThread *t = &p->threads[i];
-      if (t->inBuf)
-      {
-        ISzAlloc_Free(p->allocBig, t->inBuf);
-        t->inBuf = NULL;
-      }
-    }
-    p->allocatedBufsSize = p->blockSize;
-  }
-
-  p->readRes = SZ_OK;
-
-  MtProgress_Init(&p->mtProgress, p->progress);
-
-  #ifdef MTCODER__USE_WRITE_THREAD
-    for (i = 0; i < numBlocksMax; i++)
-    {
-      RINOK_THREAD(ArEvent_OptCreate_And_Reset(&p->writeEvents[i]));
-    }
-  #else
-    RINOK_THREAD(ArEvent_OptCreate_And_Reset(&p->finishedEvent));
-  #endif
-
-  {
-    RINOK_THREAD(ArEvent_OptCreate_And_Reset(&p->readEvent));
-    RINOK_THREAD(Semaphore_OptCreateInit(&p->blocksSemaphore, numBlocksMax, numBlocksMax));
-  }
-
-  for (i = 0; i < MTCODER__BLOCKS_MAX - 1; i++)
-    p->freeBlockList[i] = i + 1;
-  p->freeBlockList[MTCODER__BLOCKS_MAX - 1] = (unsigned)(int)-1;
-  p->freeBlockHead = 0;
-
-  p->readProcessed = 0;
-  p->blockIndex = 0;
-  p->numBlocksMax = numBlocksMax;
-  p->stopReading = False;
-
-  #ifndef MTCODER__USE_WRITE_THREAD
-    p->writeIndex = 0;
-    p->writeRes = SZ_OK;
-    for (i = 0; i < MTCODER__BLOCKS_MAX; i++)
-      p->ReadyBlocks[i] = False;
-    p->numFinishedThreads = 0;
-  #endif
-
-  p->numStartedThreadsLimit = numThreads;
-  p->numStartedThreads = 0;
-
-  // for (i = 0; i < numThreads; i++)
-  {
-    CMtCoderThread *nextThread = &p->threads[p->numStartedThreads++];
-    RINOK(MtCoderThread_CreateAndStart(nextThread));
-  }
-
-  RINOK_THREAD(Event_Set(&p->readEvent))
-
-  #ifdef MTCODER__USE_WRITE_THREAD
-  {
-    unsigned bi = 0;
-
-    for (;; bi++)
-    {
-      if (bi >= numBlocksMax)
-        bi = 0;
-
-      RINOK_THREAD(Event_Wait(&p->writeEvents[bi]))
-
-      {
-        const CMtCoderBlock *block = &p->blocks[bi];
-        unsigned bufIndex = block->bufIndex;
-        BoolInt finished = block->finished;
-        if (res == SZ_OK && block->res != SZ_OK)
-          res = block->res;
-
-        if (bufIndex != (unsigned)(int)-1)
-        {
-          if (res == SZ_OK)
-          {
-            res = p->mtCallback->Write(p->mtCallbackObject, bufIndex);
-            if (res != SZ_OK)
-              MtProgress_SetError(&p->mtProgress, res);
-          }
-          
-          CriticalSection_Enter(&p->cs);
-          {
-            p->freeBlockList[bufIndex] = p->freeBlockHead;
-            p->freeBlockHead = bufIndex;
-          }
-          CriticalSection_Leave(&p->cs);
-        }
-        
-        RINOK_THREAD(Semaphore_Release1(&p->blocksSemaphore))
-
-        if (finished)
-          break;
-      }
-    }
-  }
-  #else
-  {
-    WRes wres = Event_Wait(&p->finishedEvent);
-    res = MY_SRes_HRESULT_FROM_WRes(wres);
-  }
-  #endif
-
-  if (res == SZ_OK)
-    res = p->readRes;
-
-  if (res == SZ_OK)
-    res = p->mtProgress.res;
-
-  #ifndef MTCODER__USE_WRITE_THREAD
-    if (res == SZ_OK)
-      res = p->writeRes;
-  #endif
-
-  if (res != SZ_OK)
-    MtCoder_Free(p);
-  return res;
-}
-
-#endif

3rdparty/7z/src/MtCoder.h

@@ -1,141 +0,0 @@
-/* MtCoder.h -- Multi-thread Coder
-2018-07-04 : Igor Pavlov : Public domain */
-
-#ifndef __MT_CODER_H
-#define __MT_CODER_H
-
-#include "MtDec.h"
-
-EXTERN_C_BEGIN
-
-/*
-  if (    defined MTCODER__USE_WRITE_THREAD) : main thread writes all data blocks to output stream
-  if (not defined MTCODER__USE_WRITE_THREAD) : any coder thread can write data blocks to output stream
-*/
-/* #define MTCODER__USE_WRITE_THREAD */
-
-#ifndef _7ZIP_ST
-  #define MTCODER__GET_NUM_BLOCKS_FROM_THREADS(numThreads) ((numThreads) + (numThreads) / 8 + 1)
-  #define MTCODER__THREADS_MAX 64
-  #define MTCODER__BLOCKS_MAX (MTCODER__GET_NUM_BLOCKS_FROM_THREADS(MTCODER__THREADS_MAX) + 3)
-#else
-  #define MTCODER__THREADS_MAX 1
-  #define MTCODER__BLOCKS_MAX 1
-#endif
-
-
-#ifndef _7ZIP_ST
-
-
-typedef struct
-{
-  ICompressProgress vt;
-  CMtProgress *mtProgress;
-  UInt64 inSize;
-  UInt64 outSize;
-} CMtProgressThunk;
-
-void MtProgressThunk_CreateVTable(CMtProgressThunk *p);
-    
-#define MtProgressThunk_Init(p) { (p)->inSize = 0; (p)->outSize = 0; }
-
-
-struct _CMtCoder;
-
-
-typedef struct
-{
-  struct _CMtCoder *mtCoder;
-  unsigned index;
-  int stop;
-  Byte *inBuf;
-
-  CAutoResetEvent startEvent;
-  CThread thread;
-} CMtCoderThread;
-
-
-typedef struct
-{
-  SRes (*Code)(void *p, unsigned coderIndex, unsigned outBufIndex,
-      const Byte *src, size_t srcSize, int finished);
-  SRes (*Write)(void *p, unsigned outBufIndex);
-} IMtCoderCallback2;
-
-
-typedef struct
-{
-  SRes res;
-  unsigned bufIndex;
-  BoolInt finished;
-} CMtCoderBlock;
-
-
-typedef struct _CMtCoder
-{
-  /* input variables */
-  
-  size_t blockSize;        /* size of input block */
-  unsigned numThreadsMax;
-  UInt64 expectedDataSize;
-
-  ISeqInStream *inStream;
-  const Byte *inData;
-  size_t inDataSize;
-
-  ICompressProgress *progress;
-  ISzAllocPtr allocBig;
-
-  IMtCoderCallback2 *mtCallback;
-  void *mtCallbackObject;
-
-  
-  /* internal variables */
-  
-  size_t allocatedBufsSize;
-
-  CAutoResetEvent readEvent;
-  CSemaphore blocksSemaphore;
-
-  BoolInt stopReading;
-  SRes readRes;
-
-  #ifdef MTCODER__USE_WRITE_THREAD
-    CAutoResetEvent writeEvents[MTCODER__BLOCKS_MAX];
-  #else
-    CAutoResetEvent finishedEvent;
-    SRes writeRes;
-    unsigned writeIndex;
-    Byte ReadyBlocks[MTCODER__BLOCKS_MAX];
-    LONG numFinishedThreads;
-  #endif
-
-  unsigned numStartedThreadsLimit;
-  unsigned numStartedThreads;
-
-  unsigned numBlocksMax;
-  unsigned blockIndex;
-  UInt64 readProcessed;
-
-  CCriticalSection cs;
-
-  unsigned freeBlockHead;
-  unsigned freeBlockList[MTCODER__BLOCKS_MAX];
-
-  CMtProgress mtProgress;
-  CMtCoderBlock blocks[MTCODER__BLOCKS_MAX];
-  CMtCoderThread threads[MTCODER__THREADS_MAX];
-} CMtCoder;
-
-
-void MtCoder_Construct(CMtCoder *p);
-void MtCoder_Destruct(CMtCoder *p);
-SRes MtCoder_Code(CMtCoder *p);
-
-
-#endif
-
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/MtDec.h

@@ -1,202 +0,0 @@
-/* MtDec.h -- Multi-thread Decoder
-2020-03-05 : Igor Pavlov : Public domain */
-
-#ifndef __MT_DEC_H
-#define __MT_DEC_H
-
-#include "7zTypes.h"
-
-#ifndef _7ZIP_ST
-#include "Threads.h"
-#endif
-
-EXTERN_C_BEGIN
-
-#ifndef _7ZIP_ST
-
-#ifndef _7ZIP_ST
-  #define MTDEC__THREADS_MAX 32
-#else
-  #define MTDEC__THREADS_MAX 1
-#endif
-
-
-typedef struct
-{
-  ICompressProgress *progress;
-  SRes res;
-  UInt64 totalInSize;
-  UInt64 totalOutSize;
-  CCriticalSection cs;
-} CMtProgress;
-
-void MtProgress_Init(CMtProgress *p, ICompressProgress *progress);
-SRes MtProgress_Progress_ST(CMtProgress *p);
-SRes MtProgress_ProgressAdd(CMtProgress *p, UInt64 inSize, UInt64 outSize);
-SRes MtProgress_GetError(CMtProgress *p);
-void MtProgress_SetError(CMtProgress *p, SRes res);
-
-struct _CMtDec;
-
-typedef struct
-{
-  struct _CMtDec *mtDec;
-  unsigned index;
-  void *inBuf;
-
-  size_t inDataSize_Start; // size of input data in start block
-  UInt64 inDataSize;       // total size of input data in all blocks
-
-  CThread thread;
-  CAutoResetEvent canRead;
-  CAutoResetEvent canWrite;
-  void  *allocaPtr;
-} CMtDecThread;
-
-void MtDecThread_FreeInBufs(CMtDecThread *t);
-
-
-typedef enum
-{
-  MTDEC_PARSE_CONTINUE, // continue this block with more input data
-  MTDEC_PARSE_OVERFLOW, // MT buffers overflow, need switch to single-thread
-  MTDEC_PARSE_NEW,      // new block
-  MTDEC_PARSE_END       // end of block threading. But we still can return to threading after Write(&needContinue)
-} EMtDecParseState;
-
-typedef struct
-{
-  // in
-  int startCall;
-  const Byte *src;
-  size_t srcSize;
-      // in  : (srcSize == 0) is allowed
-      // out : it's allowed to return less that actually was used ?
-  int srcFinished;
-
-  // out
-  EMtDecParseState state;
-  BoolInt canCreateNewThread;
-  UInt64 outPos; // check it (size_t)
-} CMtDecCallbackInfo;
-
-
-typedef struct
-{
-  void (*Parse)(void *p, unsigned coderIndex, CMtDecCallbackInfo *ci);
-  
-  // PreCode() and Code():
-  // (SRes_return_result != SZ_OK) means stop decoding, no need another blocks
-  SRes (*PreCode)(void *p, unsigned coderIndex);
-  SRes (*Code)(void *p, unsigned coderIndex,
-      const Byte *src, size_t srcSize, int srcFinished,
-      UInt64 *inCodePos, UInt64 *outCodePos, int *stop);
-  // stop - means stop another Code calls
-
-
-  /* Write() must be called, if Parse() was called
-      set (needWrite) if
-      {
-         && (was not interrupted by progress)
-         && (was not interrupted in previous block)
-      }
-
-    out:
-      if (*needContinue), decoder still need to continue decoding with new iteration,
-         even after MTDEC_PARSE_END
-      if (*canRecode), we didn't flush current block data, so we still can decode current block later.
-  */
-  SRes (*Write)(void *p, unsigned coderIndex,
-      BoolInt needWriteToStream,
-      const Byte *src, size_t srcSize, BoolInt isCross,
-      // int srcFinished,
-      BoolInt *needContinue,
-      BoolInt *canRecode);
-
-} IMtDecCallback2;
-
-
-
-typedef struct _CMtDec
-{
-  /* input variables */
-  
-  size_t inBufSize;        /* size of input block */
-  unsigned numThreadsMax;
-  // size_t inBlockMax;
-  unsigned numThreadsMax_2;
-
-  ISeqInStream *inStream;
-  // const Byte *inData;
-  // size_t inDataSize;
-
-  ICompressProgress *progress;
-  ISzAllocPtr alloc;
-
-  IMtDecCallback2 *mtCallback;
-  void *mtCallbackObject;
-
-  
-  /* internal variables */
-  
-  size_t allocatedBufsSize;
-
-  BoolInt exitThread;
-  WRes exitThreadWRes;
-
-  UInt64 blockIndex;
-  BoolInt isAllocError;
-  BoolInt overflow;
-  SRes threadingErrorSRes;
-
-  BoolInt needContinue;
-
-  // CAutoResetEvent finishedEvent;
-
-  SRes readRes;
-  SRes codeRes;
-
-  BoolInt wasInterrupted;
-
-  unsigned numStartedThreads_Limit;
-  unsigned numStartedThreads;
-
-  Byte *crossBlock;
-  size_t crossStart;
-  size_t crossEnd;
-  UInt64 readProcessed;
-  BoolInt readWasFinished;
-  UInt64 inProcessed;
-
-  unsigned filledThreadStart;
-  unsigned numFilledThreads;
-
-  #ifndef _7ZIP_ST
-  BoolInt needInterrupt;
-  UInt64 interruptIndex;
-  CMtProgress mtProgress;
-  CMtDecThread threads[MTDEC__THREADS_MAX];
-  #endif
-} CMtDec;
-
-
-void MtDec_Construct(CMtDec *p);
-void MtDec_Destruct(CMtDec *p);
-
-/*
-MtDec_Code() returns:
-  SZ_OK - in most cases
-  MY_SRes_HRESULT_FROM_WRes(WRes_error) - in case of unexpected error in threading function
-*/
-  
-SRes MtDec_Code(CMtDec *p);
-Byte *MtDec_GetCrossBuff(CMtDec *p);
-
-int MtDec_PrepareRead(CMtDec *p);
-const Byte *MtDec_Read(CMtDec *p, size_t *inLim);
-
-#endif
-
-EXTERN_C_END
-
-#endif

3rdparty/7z/src/Ppmd.h

@@ -1,167 +0,0 @@
-/* Ppmd.h -- PPMD codec common code
-2021-04-13 : Igor Pavlov : Public domain
-This code is based on PPMd var.H (2001): Dmitry Shkarin : Public domain */
-
-#ifndef __PPMD_H
-#define __PPMD_H
-
-#include "CpuArch.h"
-
-EXTERN_C_BEGIN
-
-#if defined(MY_CPU_SIZEOF_POINTER) && (MY_CPU_SIZEOF_POINTER == 4)
-/*
-   PPMD code always uses 32-bit internal fields in PPMD structures to store internal references in main block.
-   if (PPMD_32BIT is     defined), the PPMD code stores internal pointers to 32-bit reference fields.
-   if (PPMD_32BIT is NOT defined), the PPMD code stores internal UInt32 offsets to reference fields.
-   if (pointer size is 64-bit), then (PPMD_32BIT) mode is not allowed,
-   if (pointer size is 32-bit), then (PPMD_32BIT) mode is optional,
-     and it's allowed to disable PPMD_32BIT mode even if pointer is 32-bit.
-   PPMD code works slightly faster in (PPMD_32BIT) mode.
-*/
-  #define PPMD_32BIT
-#endif
-
-#define PPMD_INT_BITS 7
-#define PPMD_PERIOD_BITS 7
-#define PPMD_BIN_SCALE (1 << (PPMD_INT_BITS + PPMD_PERIOD_BITS))
-
-#define PPMD_GET_MEAN_SPEC(summ, shift, round) (((summ) + (1 << ((shift) - (round)))) >> (shift))
-#define PPMD_GET_MEAN(summ) PPMD_GET_MEAN_SPEC((summ), PPMD_PERIOD_BITS, 2)
-#define PPMD_UPDATE_PROB_0(prob) ((prob) + (1 << PPMD_INT_BITS) - PPMD_GET_MEAN(prob))
-#define PPMD_UPDATE_PROB_1(prob) ((prob) - PPMD_GET_MEAN(prob))
-
-#define PPMD_N1 4
-#define PPMD_N2 4
-#define PPMD_N3 4
-#define PPMD_N4 ((128 + 3 - 1 * PPMD_N1 - 2 * PPMD_N2 - 3 * PPMD_N3) / 4)
-#define PPMD_NUM_INDEXES (PPMD_N1 + PPMD_N2 + PPMD_N3 + PPMD_N4)
-
-MY_CPU_pragma_pack_push_1
-/* Most compilers works OK here even without #pragma pack(push, 1), but some GCC compilers need it. */
-
-/* SEE-contexts for PPM-contexts with masked symbols */
-typedef struct
-{
-  UInt16 Summ; /* Freq */
-  Byte Shift;  /* Speed of Freq change; low Shift is for fast change */
-  Byte Count;  /* Count to next change of Shift */
-} CPpmd_See;
-
-#define Ppmd_See_Update(p)  if ((p)->Shift < PPMD_PERIOD_BITS && --(p)->Count == 0) \
-    { (p)->Summ = (UInt16)((p)->Summ << 1); (p)->Count = (Byte)(3 << (p)->Shift++); }
-
-
-typedef struct
-{
-  Byte Symbol;
-  Byte Freq;
-  UInt16 Successor_0;
-  UInt16 Successor_1;
-} CPpmd_State;
-
-typedef struct CPpmd_State2_
-{
-  Byte Symbol;
-  Byte Freq;
-} CPpmd_State2;
-
-typedef struct CPpmd_State4_
-{
-  UInt16 Successor_0;
-  UInt16 Successor_1;
-} CPpmd_State4;
-
-MY_CPU_pragma_pop
-
-/*
-   PPMD code can write full CPpmd_State structure data to CPpmd*_Context
-      at (byte offset = 2) instead of some fields of original CPpmd*_Context structure.
-   
-   If we use pointers to different types, but that point to shared
-   memory space, we can have aliasing problem (strict aliasing).
-   
-   XLC compiler in -O2 mode can change the order of memory write instructions
-   in relation to read instructions, if we have use pointers to different types.
-   
-   To solve that aliasing problem we use combined CPpmd*_Context structure
-   with unions that contain the fields from both structures:
-   the original CPpmd*_Context and CPpmd_State.
-   So we can access the fields from both structures via one pointer,
-   and the compiler doesn't change the order of write instructions
-   in relation to read instructions.
-
-   If we don't use memory write instructions to shared memory in
-   some local code, and we use only reading instructions (read only),
-   then probably it's safe to use pointers to different types for reading.
-*/
-  
-
-
-#ifdef PPMD_32BIT
-
-  #define Ppmd_Ref_Type(type)   type *
-  #define Ppmd_GetRef(p, ptr)   (ptr)
-  #define Ppmd_GetPtr(p, ptr)   (ptr)
-  #define Ppmd_GetPtr_Type(p, ptr, note_type) (ptr)
-
-#else
-
-  #define Ppmd_Ref_Type(type)   UInt32
-  #define Ppmd_GetRef(p, ptr)   ((UInt32)((Byte *)(ptr) - (p)->Base))
-  #define Ppmd_GetPtr(p, offs)  ((void *)((p)->Base + (offs)))
-  #define Ppmd_GetPtr_Type(p, offs, type) ((type *)Ppmd_GetPtr(p, offs))
-
-#endif // PPMD_32BIT
-
-
-typedef Ppmd_Ref_Type(CPpmd_State) CPpmd_State_Ref;
-typedef Ppmd_Ref_Type(void)        CPpmd_Void_Ref;
-typedef Ppmd_Ref_Type(Byte)        CPpmd_Byte_Ref;
-
-
-/*
-#ifdef MY_CPU_LE_UNALIGN
-// the unaligned 32-bit access latency can be too large, if the data is not in L1 cache.
-#define Ppmd_GET_SUCCESSOR(p) ((CPpmd_Void_Ref)*(const UInt32 *)(const void *)&(p)->Successor_0)
-#define Ppmd_SET_SUCCESSOR(p, v) *(UInt32 *)(void *)(void *)&(p)->Successor_0 = (UInt32)(v)
-
-#else
-*/
-
-/*
-   We can write 16-bit halves to 32-bit (Successor) field in any selected order.
-   But the native order is more consistent way.
-   So we use the native order, if LE/BE order can be detected here at compile time.
-*/
-
-#ifdef MY_CPU_BE
-
-  #define Ppmd_GET_SUCCESSOR(p) \
-    ( (CPpmd_Void_Ref) (((UInt32)(p)->Successor_0 << 16) | (p)->Successor_1) )
-
-  #define Ppmd_SET_SUCCESSOR(p, v) { \
-    (p)->Successor_0 = (UInt16)(((UInt32)(v) >> 16) /* & 0xFFFF */); \
-    (p)->Successor_1 = (UInt16)((UInt32)(v) /* & 0xFFFF */); }
-
-#else
-
-  #define Ppmd_GET_SUCCESSOR(p) \
-    ( (CPpmd_Void_Ref) ((p)->Successor_0 | ((UInt32)(p)->Successor_1 << 16)) )
-
-  #define Ppmd_SET_SUCCESSOR(p, v) { \
-    (p)->Successor_0 = (UInt16)((UInt32)(v) /* & 0xFFFF */); \
-    (p)->Successor_1 = (UInt16)(((UInt32)(v) >> 16) /* & 0xFFFF */); }
-
-#endif
-
-// #endif
-
-
-#define PPMD_SetAllBitsIn256Bytes(p) \
-  { size_t z; for (z = 0; z < 256 / sizeof(p[0]); z += 8) { \
-  p[z+7] = p[z+6] = p[z+5] = p[z+4] = p[z+3] = p[z+2] = p[z+1] = p[z+0] = ~(size_t)0; }}
-
-EXTERN_C_END
- 
-#endif

3rdparty/7z/src/Ppmd7.h

@@ -1,181 +0,0 @@
-/* Ppmd7.h -- Ppmd7 (PPMdH) compression codec
-2021-04-13 : Igor Pavlov : Public domain
-This code is based on:
-  PPMd var.H (2001): Dmitry Shkarin : Public domain */
- 
-
-#ifndef __PPMD7_H
-#define __PPMD7_H
-
-#include "Ppmd.h"
-
-EXTERN_C_BEGIN
-
-#define PPMD7_MIN_ORDER 2
-#define PPMD7_MAX_ORDER 64
-
-#define PPMD7_MIN_MEM_SIZE (1 << 11)
-#define PPMD7_MAX_MEM_SIZE (0xFFFFFFFF - 12 * 3)
-
-struct CPpmd7_Context_;
-
-typedef Ppmd_Ref_Type(struct CPpmd7_Context_) CPpmd7_Context_Ref;
-
-// MY_CPU_pragma_pack_push_1
-
-typedef struct CPpmd7_Context_
-{
-  UInt16 NumStats;
-
-
-  union
-  {
-    UInt16 SummFreq;
-    CPpmd_State2 State2;
-  } Union2;
-
-  union
-  {
-    CPpmd_State_Ref Stats;
-    CPpmd_State4 State4;
-  } Union4;
-
-  CPpmd7_Context_Ref Suffix;
-} CPpmd7_Context;
-
-// MY_CPU_pragma_pop
-
-#define Ppmd7Context_OneState(p) ((CPpmd_State *)&(p)->Union2)
-
-
-
-
-typedef struct
-{
-  UInt32 Range;
-  UInt32 Code;
-  UInt32 Low;
-  IByteIn *Stream;
-} CPpmd7_RangeDec;
-
-
-typedef struct
-{
-  UInt32 Range;
-  Byte Cache;
-  // Byte _dummy_[3];
-  UInt64 Low;
-  UInt64 CacheSize;
-  IByteOut *Stream;
-} CPpmd7z_RangeEnc;
-
-
-typedef struct
-{
-  CPpmd7_Context *MinContext, *MaxContext;
-  CPpmd_State *FoundState;
-  unsigned OrderFall, InitEsc, PrevSuccess, MaxOrder, HiBitsFlag;
-  Int32 RunLength, InitRL; /* must be 32-bit at least */
-
-  UInt32 Size;
-  UInt32 GlueCount;
-  UInt32 AlignOffset;
-  Byte *Base, *LoUnit, *HiUnit, *Text, *UnitsStart;
-
-
-  
-  
-  union
-  {
-    CPpmd7_RangeDec dec;
-    CPpmd7z_RangeEnc enc;
-  } rc;
-  
-  Byte Indx2Units[PPMD_NUM_INDEXES + 2]; // +2 for alignment
-  Byte Units2Indx[128];
-  CPpmd_Void_Ref FreeList[PPMD_NUM_INDEXES];
-
-  Byte NS2BSIndx[256], NS2Indx[256];
-  Byte ExpEscape[16];
-  CPpmd_See DummySee, See[25][16];
-  UInt16 BinSumm[128][64];
-  // int LastSymbol;
-} CPpmd7;
-
-
-void Ppmd7_Construct(CPpmd7 *p);
-BoolInt Ppmd7_Alloc(CPpmd7 *p, UInt32 size, ISzAllocPtr alloc);
-void Ppmd7_Free(CPpmd7 *p, ISzAllocPtr alloc);
-void Ppmd7_Init(CPpmd7 *p, unsigned maxOrder);
-#define Ppmd7_WasAllocated(p) ((p)->Base != NULL)
-
-
-/* ---------- Internal Functions ---------- */
-
-#define Ppmd7_GetPtr(p, ptr)     Ppmd_GetPtr(p, ptr)
-#define Ppmd7_GetContext(p, ptr) Ppmd_GetPtr_Type(p, ptr, CPpmd7_Context)
-#define Ppmd7_GetStats(p, ctx)   Ppmd_GetPtr_Type(p, (ctx)->Union4.Stats, CPpmd_State)
-
-void Ppmd7_Update1(CPpmd7 *p);
-void Ppmd7_Update1_0(CPpmd7 *p);
-void Ppmd7_Update2(CPpmd7 *p);
-
-#define PPMD7_HiBitsFlag_3(sym) ((((unsigned)sym + 0xC0) >> (8 - 3)) & (1 << 3))
-#define PPMD7_HiBitsFlag_4(sym) ((((unsigned)sym + 0xC0) >> (8 - 4)) & (1 << 4))
-// #define PPMD7_HiBitsFlag_3(sym) ((sym) < 0x40 ? 0 : (1 << 3))
-// #define PPMD7_HiBitsFlag_4(sym) ((sym) < 0x40 ? 0 : (1 << 4))
-
-#define Ppmd7_GetBinSumm(p) \
-    &p->BinSumm[(size_t)(unsigned)Ppmd7Context_OneState(p->MinContext)->Freq - 1] \
-    [ p->PrevSuccess + ((p->RunLength >> 26) & 0x20) \
-    + p->NS2BSIndx[(size_t)Ppmd7_GetContext(p, p->MinContext->Suffix)->NumStats - 1] \
-    + PPMD7_HiBitsFlag_4(Ppmd7Context_OneState(p->MinContext)->Symbol) \
-    + (p->HiBitsFlag = PPMD7_HiBitsFlag_3(p->FoundState->Symbol)) ]
-
-CPpmd_See *Ppmd7_MakeEscFreq(CPpmd7 *p, unsigned numMasked, UInt32 *scale);
-
-
-/*
-We support two versions of Ppmd7 (PPMdH) methods that use same CPpmd7 structure:
-  1) Ppmd7a_*: original PPMdH
-  2) Ppmd7z_*: modified PPMdH with 7z Range Coder
-Ppmd7_*: the structures and functions that are common for both versions of PPMd7 (PPMdH)
-*/
-
-/* ---------- Decode ---------- */
-
-#define PPMD7_SYM_END    (-1)
-#define PPMD7_SYM_ERROR  (-2)
-
-/*
-You must set (CPpmd7::rc.dec.Stream) before Ppmd7*_RangeDec_Init()
-
-Ppmd7*_DecodeSymbol()
-out:
-  >= 0 : decoded byte
-    -1 : PPMD7_SYM_END   : End of payload marker
-    -2 : PPMD7_SYM_ERROR : Data error
-*/
-
-/* Ppmd7a_* : original PPMdH */
-BoolInt Ppmd7a_RangeDec_Init(CPpmd7_RangeDec *p);
-#define Ppmd7a_RangeDec_IsFinishedOK(p) ((p)->Code == 0)
-int Ppmd7a_DecodeSymbol(CPpmd7 *p);
-
-/* Ppmd7z_* : modified PPMdH with 7z Range Coder */
-BoolInt Ppmd7z_RangeDec_Init(CPpmd7_RangeDec *p);
-#define Ppmd7z_RangeDec_IsFinishedOK(p) ((p)->Code == 0)
-int Ppmd7z_DecodeSymbol(CPpmd7 *p);
-// Byte *Ppmd7z_DecodeSymbols(CPpmd7 *p, Byte *buf, const Byte *lim);
-
-
-/* ---------- Encode ---------- */
-
-void Ppmd7z_Init_RangeEnc(CPpmd7 *p);
-void Ppmd7z_Flush_RangeEnc(CPpmd7 *p);
-// void Ppmd7z_EncodeSymbol(CPpmd7 *p, int symbol);
-void Ppmd7z_EncodeSymbols(CPpmd7 *p, const Byte *buf, const Byte *lim);
-
-EXTERN_C_END
- 
-#endif

3rdparty/7z/src/Ppmd7Dec.c

@@ -1,297 +0,0 @@
-/* Ppmd7Dec.c -- Ppmd7z (PPMdH with 7z Range Coder) Decoder
-2021-04-13 : Igor Pavlov : Public domain
-This code is based on:
-  PPMd var.H (2001): Dmitry Shkarin : Public domain */
-
-
-#include "Precomp.h"
-
-#include "Ppmd7.h"
-
-#define kTopValue (1 << 24)
-
-
-#define READ_BYTE(p) IByteIn_Read((p)->Stream)
-
-BoolInt Ppmd7z_RangeDec_Init(CPpmd7_RangeDec *p)
-{
-  unsigned i;
-  p->Code = 0;
-  p->Range = 0xFFFFFFFF;
-  if (READ_BYTE(p) != 0)
-    return False;
-  for (i = 0; i < 4; i++)
-    p->Code = (p->Code << 8) | READ_BYTE(p);
-  return (p->Code < 0xFFFFFFFF);
-}
-
-#define RC_NORM_BASE(p) if ((p)->Range < kTopValue) \
-  { (p)->Code = ((p)->Code << 8) | READ_BYTE(p); (p)->Range <<= 8;
-
-#define RC_NORM_1(p)  RC_NORM_BASE(p) }
-#define RC_NORM(p)    RC_NORM_BASE(p) RC_NORM_BASE(p) }}
-
-// we must use only one type of Normalization from two: LOCAL or REMOTE
-#define RC_NORM_LOCAL(p)    // RC_NORM(p)
-#define RC_NORM_REMOTE(p)   RC_NORM(p)
-
-#define R (&p->rc.dec)
-
-MY_FORCE_INLINE
-// MY_NO_INLINE
-static void RangeDec_Decode(CPpmd7 *p, UInt32 start, UInt32 size)
-{
-
-  
-  R->Code -= start * R->Range;
-  R->Range *= size;
-  RC_NORM_LOCAL(R)
-}
-
-#define RC_Decode(start, size) RangeDec_Decode(p, start, size);
-#define RC_DecodeFinal(start, size) RC_Decode(start, size) RC_NORM_REMOTE(R)
-#define RC_GetThreshold(total) (R->Code / (R->Range /= (total)))
-
-
-#define CTX(ref) ((CPpmd7_Context *)Ppmd7_GetContext(p, ref))
-typedef CPpmd7_Context * CTX_PTR;
-#define SUCCESSOR(p) Ppmd_GET_SUCCESSOR(p)
-void Ppmd7_UpdateModel(CPpmd7 *p);
-
-#define MASK(sym) ((unsigned char *)charMask)[sym]
-// MY_FORCE_INLINE
-// static
-int Ppmd7z_DecodeSymbol(CPpmd7 *p)
-{
-  size_t charMask[256 / sizeof(size_t)];
-
-  if (p->MinContext->NumStats != 1)
-  {
-    CPpmd_State *s = Ppmd7_GetStats(p, p->MinContext);
-    unsigned i;
-    UInt32 count, hiCnt;
-    UInt32 summFreq = p->MinContext->Union2.SummFreq;
-
-    
-    
-    
-    count = RC_GetThreshold(summFreq);
-    hiCnt = count;
-    
-    if ((Int32)(count -= s->Freq) < 0)
-    {
-      Byte sym;
-      RC_DecodeFinal(0, s->Freq);
-      p->FoundState = s;
-      sym = s->Symbol;
-      Ppmd7_Update1_0(p);
-      return sym;
-    }
-  
-    p->PrevSuccess = 0;
-    i = (unsigned)p->MinContext->NumStats - 1;
-    
-    do
-    {
-      if ((Int32)(count -= (++s)->Freq) < 0)
-      {
-        Byte sym;
-        RC_DecodeFinal((hiCnt - count) - s->Freq, s->Freq);
-        p->FoundState = s;
-        sym = s->Symbol;
-        Ppmd7_Update1(p);
-        return sym;
-      }
-    }
-    while (--i);
-    
-    if (hiCnt >= summFreq)
-      return PPMD7_SYM_ERROR;
-    
-    hiCnt -= count;
-    RC_Decode(hiCnt, summFreq - hiCnt);
-
-    p->HiBitsFlag = PPMD7_HiBitsFlag_3(p->FoundState->Symbol);
-    PPMD_SetAllBitsIn256Bytes(charMask);
-    // i = p->MinContext->NumStats - 1;
-    // do { MASK((--s)->Symbol) = 0; } while (--i);
-    {
-      CPpmd_State *s2 = Ppmd7_GetStats(p, p->MinContext);
-      MASK(s->Symbol) = 0;
-      do
-      {
-        unsigned sym0 = s2[0].Symbol;
-        unsigned sym1 = s2[1].Symbol;
-        s2 += 2;
-        MASK(sym0) = 0;
-        MASK(sym1) = 0;
-      }
-      while (s2 < s);
-    }
-  }
-  else
-  {
-    CPpmd_State *s = Ppmd7Context_OneState(p->MinContext);
-    UInt16 *prob = Ppmd7_GetBinSumm(p);
-    UInt32 pr = *prob;
-    UInt32 size0 = (R->Range >> 14) * pr;
-    pr = PPMD_UPDATE_PROB_1(pr);
-
-    if (R->Code < size0)
-    {
-      Byte sym;
-      *prob = (UInt16)(pr + (1 << PPMD_INT_BITS));
-      
-      // RangeDec_DecodeBit0(size0);
-      R->Range = size0;
-      RC_NORM_1(R)
-      /* we can use single byte normalization here because of
-         (min(BinSumm[][]) = 95) > (1 << (14 - 8)) */
-
-      // sym = (p->FoundState = Ppmd7Context_OneState(p->MinContext))->Symbol;
-      // Ppmd7_UpdateBin(p);
-      {
-        unsigned freq = s->Freq;
-        CTX_PTR c = CTX(SUCCESSOR(s));
-        sym = s->Symbol;
-        p->FoundState = s;
-        p->PrevSuccess = 1;
-        p->RunLength++;
-        s->Freq = (Byte)(freq + (freq < 128));
-        // NextContext(p);
-        if (p->OrderFall == 0 && (const Byte *)c > p->Text)
-          p->MaxContext = p->MinContext = c;
-        else
-          Ppmd7_UpdateModel(p);
-      }
-      return sym;
-    }
-
-    *prob = (UInt16)pr;
-    p->InitEsc = p->ExpEscape[pr >> 10];
-
-    // RangeDec_DecodeBit1(size0);
-    
-    R->Code -= size0;
-    R->Range -= size0;
-    RC_NORM_LOCAL(R)
-    
-    PPMD_SetAllBitsIn256Bytes(charMask);
-    MASK(Ppmd7Context_OneState(p->MinContext)->Symbol) = 0;
-    p->PrevSuccess = 0;
-  }
-
-  for (;;)
-  {
-    CPpmd_State *s, *s2;
-    UInt32 freqSum, count, hiCnt;
-
-    CPpmd_See *see;
-    CPpmd7_Context *mc;
-    unsigned numMasked;
-    RC_NORM_REMOTE(R)
-    mc = p->MinContext;
-    numMasked = mc->NumStats;
-
-    do
-    {
-      p->OrderFall++;
-      if (!mc->Suffix)
-        return PPMD7_SYM_END;
-      mc = Ppmd7_GetContext(p, mc->Suffix);
-    }
-    while (mc->NumStats == numMasked);
-    
-    s = Ppmd7_GetStats(p, mc);
-
-    {
-      unsigned num = mc->NumStats;
-      unsigned num2 = num / 2;
-      
-      num &= 1;
-      hiCnt = (s->Freq & (unsigned)(MASK(s->Symbol))) & (0 - (UInt32)num);
-      s += num;
-      p->MinContext = mc;
-
-      do
-      {
-        unsigned sym0 = s[0].Symbol;
-        unsigned sym1 = s[1].Symbol;
-        s += 2;
-        hiCnt += (s[-2].Freq & (unsigned)(MASK(sym0)));
-        hiCnt += (s[-1].Freq & (unsigned)(MASK(sym1)));
-      }
-      while (--num2);
-    }
-
-    see = Ppmd7_MakeEscFreq(p, numMasked, &freqSum);
-    freqSum += hiCnt;
-
-
-
-
-    count = RC_GetThreshold(freqSum);
-    
-    if (count < hiCnt)
-    {
-      Byte sym;
-
-      s = Ppmd7_GetStats(p, p->MinContext);
-      hiCnt = count;
-      // count -= s->Freq & (unsigned)(MASK(s->Symbol));
-      // if ((Int32)count >= 0)
-      {
-        for (;;)
-        {
-          count -= s->Freq & (unsigned)(MASK((s)->Symbol)); s++; if ((Int32)count < 0) break;
-          // count -= s->Freq & (unsigned)(MASK((s)->Symbol)); s++; if ((Int32)count < 0) break;
-        };
-      }
-      s--;
-      RC_DecodeFinal((hiCnt - count) - s->Freq, s->Freq);
-
-      // new (see->Summ) value can overflow over 16-bits in some rare cases
-      Ppmd_See_Update(see);
-      p->FoundState = s;
-      sym = s->Symbol;
-      Ppmd7_Update2(p);
-      return sym;
-    }
-
-    if (count >= freqSum)
-      return PPMD7_SYM_ERROR;
-    
-    RC_Decode(hiCnt, freqSum - hiCnt);
-
-    // We increase (see->Summ) for sum of Freqs of all non_Masked symbols.
-    // new (see->Summ) value can overflow over 16-bits in some rare cases
-    see->Summ = (UInt16)(see->Summ + freqSum);
-
-    s = Ppmd7_GetStats(p, p->MinContext);
-    s2 = s + p->MinContext->NumStats;
-    do
-    {
-      MASK(s->Symbol) = 0;
-      s++;
-    }
-    while (s != s2);
-  }
-}
-
-/*
-Byte *Ppmd7z_DecodeSymbols(CPpmd7 *p, Byte *buf, const Byte *lim)
-{
-  int sym = 0;
-  if (buf != lim)
-  do
-  {
-    sym = Ppmd7z_DecodeSymbol(p);
-    if (sym < 0)
-      break;
-    *buf = (Byte)sym;
-  }
-  while (++buf < lim);
-  p->LastSymbol = sym;
-  return buf;
-}
-*/

3rdparty/7z/src/Ppmd7Enc.c

@@ -1,323 +0,0 @@
-/* Ppmd7Enc.c -- Ppmd7z (PPMdH with 7z Range Coder) Encoder
-2021-04-13 : Igor Pavlov : Public domain
-This code is based on:
-  PPMd var.H (2001): Dmitry Shkarin : Public domain */
-
-
-#include "Precomp.h"
-
-#include "Ppmd7.h"
-
-#define kTopValue (1 << 24)
-
-#define R (&p->rc.enc)
-
-void Ppmd7z_Init_RangeEnc(CPpmd7 *p)
-{
-  R->Low = 0;
-  R->Range = 0xFFFFFFFF;
-  R->Cache = 0;
-  R->CacheSize = 1;
-}
-
-MY_NO_INLINE
-static void RangeEnc_ShiftLow(CPpmd7 *p)
-{
-  if ((UInt32)R->Low < (UInt32)0xFF000000 || (unsigned)(R->Low >> 32) != 0)
-  {
-    Byte temp = R->Cache;
-    do
-    {
-      IByteOut_Write(R->Stream, (Byte)(temp + (Byte)(R->Low >> 32)));
-      temp = 0xFF;
-    }
-    while (--R->CacheSize != 0);
-    R->Cache = (Byte)((UInt32)R->Low >> 24);
-  }
-  R->CacheSize++;
-  R->Low = (UInt32)((UInt32)R->Low << 8);
-}
-
-#define RC_NORM_BASE(p) if (R->Range < kTopValue) { R->Range <<= 8; RangeEnc_ShiftLow(p);
-#define RC_NORM_1(p) RC_NORM_BASE(p) }
-#define RC_NORM(p) RC_NORM_BASE(p) RC_NORM_BASE(p) }}
-
-// we must use only one type of Normalization from two: LOCAL or REMOTE
-#define RC_NORM_LOCAL(p)    // RC_NORM(p)
-#define RC_NORM_REMOTE(p)   RC_NORM(p)
-
-/*
-#define RangeEnc_Encode(p, start, _size_) \
-  { UInt32 size = _size_; \
-    R->Low += start * R->Range; \
-    R->Range *= size; \
-    RC_NORM_LOCAL(p); }
-*/
-
-MY_FORCE_INLINE
-// MY_NO_INLINE
-static void RangeEnc_Encode(CPpmd7 *p, UInt32 start, UInt32 size)
-{
-  R->Low += start * R->Range;
-  R->Range *= size;
-  RC_NORM_LOCAL(p);
-}
-
-void Ppmd7z_Flush_RangeEnc(CPpmd7 *p)
-{
-  unsigned i;
-  for (i = 0; i < 5; i++)
-    RangeEnc_ShiftLow(p);
-}
-
-
-
-#define RC_Encode(start, size) RangeEnc_Encode(p, start, size);
-#define RC_EncodeFinal(start, size) RC_Encode(start, size); RC_NORM_REMOTE(p);
-
-#define CTX(ref) ((CPpmd7_Context *)Ppmd7_GetContext(p, ref))
-#define SUFFIX(ctx) CTX((ctx)->Suffix)
-typedef CPpmd7_Context * CTX_PTR;
-#define SUCCESSOR(p) Ppmd_GET_SUCCESSOR(p)
-
-void Ppmd7_UpdateModel(CPpmd7 *p);
-
-#define MASK(sym) ((unsigned char *)charMask)[sym]
-
-MY_FORCE_INLINE
-static
-void Ppmd7z_EncodeSymbol(CPpmd7 *p, int symbol)
-{
-  size_t charMask[256 / sizeof(size_t)];
-  
-  if (p->MinContext->NumStats != 1)
-  {
-    CPpmd_State *s = Ppmd7_GetStats(p, p->MinContext);
-    UInt32 sum;
-    unsigned i;
-   
-
-    
-    
-    R->Range /= p->MinContext->Union2.SummFreq;
-    
-    if (s->Symbol == symbol)
-    {
-      // R->Range /= p->MinContext->Union2.SummFreq;
-      RC_EncodeFinal(0, s->Freq);
-      p->FoundState = s;
-      Ppmd7_Update1_0(p);
-      return;
-    }
-    p->PrevSuccess = 0;
-    sum = s->Freq;
-    i = (unsigned)p->MinContext->NumStats - 1;
-    do
-    {
-      if ((++s)->Symbol == symbol)
-      {
-        // R->Range /= p->MinContext->Union2.SummFreq;
-        RC_EncodeFinal(sum, s->Freq);
-        p->FoundState = s;
-        Ppmd7_Update1(p);
-        return;
-      }
-      sum += s->Freq;
-    }
-    while (--i);
-
-    // R->Range /= p->MinContext->Union2.SummFreq;
-    RC_Encode(sum, p->MinContext->Union2.SummFreq - sum);
-    
-    p->HiBitsFlag = PPMD7_HiBitsFlag_3(p->FoundState->Symbol);
-    PPMD_SetAllBitsIn256Bytes(charMask);
-    // MASK(s->Symbol) = 0;
-    // i = p->MinContext->NumStats - 1;
-    // do { MASK((--s)->Symbol) = 0; } while (--i);
-    {
-      CPpmd_State *s2 = Ppmd7_GetStats(p, p->MinContext);
-      MASK(s->Symbol) = 0;
-      do
-      {
-        unsigned sym0 = s2[0].Symbol;
-        unsigned sym1 = s2[1].Symbol;
-        s2 += 2;
-        MASK(sym0) = 0;
-        MASK(sym1) = 0;
-      }
-      while (s2 < s);
-    }
-  }
-  else
-  {
-    UInt16 *prob = Ppmd7_GetBinSumm(p);
-    CPpmd_State *s = Ppmd7Context_OneState(p->MinContext);
-    UInt32 pr = *prob;
-    UInt32 bound = (R->Range >> 14) * pr;
-    pr = PPMD_UPDATE_PROB_1(pr);
-    if (s->Symbol == symbol)
-    {
-      *prob = (UInt16)(pr + (1 << PPMD_INT_BITS));
-      // RangeEnc_EncodeBit_0(p, bound);
-      R->Range = bound;
-      RC_NORM_1(p);
-      
-      // p->FoundState = s;
-      // Ppmd7_UpdateBin(p);
-      {
-        unsigned freq = s->Freq;
-        CTX_PTR c = CTX(SUCCESSOR(s));
-        p->FoundState = s;
-        p->PrevSuccess = 1;
-        p->RunLength++;
-        s->Freq = (Byte)(freq + (freq < 128));
-        // NextContext(p);
-        if (p->OrderFall == 0 && (const Byte *)c > p->Text)
-          p->MaxContext = p->MinContext = c;
-        else
-          Ppmd7_UpdateModel(p);
-      }
-      return;
-    }
-
-    *prob = (UInt16)pr;
-    p->InitEsc = p->ExpEscape[pr >> 10];
-    // RangeEnc_EncodeBit_1(p, bound);
-    R->Low += bound;
-    R->Range -= bound;
-    RC_NORM_LOCAL(p)
-    
-    PPMD_SetAllBitsIn256Bytes(charMask);
-    MASK(s->Symbol) = 0;
-    p->PrevSuccess = 0;
-  }
-
-  for (;;)
-  {
-    CPpmd_See *see;
-    CPpmd_State *s;
-    UInt32 sum, escFreq;
-    CPpmd7_Context *mc;
-    unsigned i, numMasked;
-    
-    RC_NORM_REMOTE(p)
-
-    mc = p->MinContext;
-    numMasked = mc->NumStats;
-
-    do
-    {
-      p->OrderFall++;
-      if (!mc->Suffix)
-        return; /* EndMarker (symbol = -1) */
-      mc = Ppmd7_GetContext(p, mc->Suffix);
-      i = mc->NumStats;
-    }
-    while (i == numMasked);
-
-    p->MinContext = mc;
-    
-    // see = Ppmd7_MakeEscFreq(p, numMasked, &escFreq);
-    {
-      if (i != 256)
-      {
-        unsigned nonMasked = i - numMasked;
-        see = p->See[(unsigned)p->NS2Indx[(size_t)nonMasked - 1]]
-            + p->HiBitsFlag
-            + (nonMasked < (unsigned)SUFFIX(mc)->NumStats - i)
-            + 2 * (unsigned)(mc->Union2.SummFreq < 11 * i)
-            + 4 * (unsigned)(numMasked > nonMasked);
-        {
-          // if (see->Summ) field is larger than 16-bit, we need only low 16 bits of Summ
-          unsigned summ = (UInt16)see->Summ; // & 0xFFFF
-          unsigned r = (summ >> see->Shift);
-          see->Summ = (UInt16)(summ - r);
-          escFreq = r + (r == 0);
-        }
-      }
-      else
-      {
-        see = &p->DummySee;
-        escFreq = 1;
-      }
-    }
-
-    s = Ppmd7_GetStats(p, mc);
-    sum = 0;
-    // i = mc->NumStats;
-
-    do
-    {
-      unsigned cur = s->Symbol;
-      if ((int)cur == symbol)
-      {
-        UInt32 low = sum;
-        UInt32 freq = s->Freq;
-        unsigned num2;
-
-        Ppmd_See_Update(see);
-        p->FoundState = s;
-        sum += escFreq;
-
-        num2 = i / 2;
-        i &= 1;
-        sum += freq & (0 - (UInt32)i);
-        if (num2 != 0)
-        {
-          s += i;
-          for (;;)
-          {
-            unsigned sym0 = s[0].Symbol;
-            unsigned sym1 = s[1].Symbol;
-            s += 2;
-            sum += (s[-2].Freq & (unsigned)(MASK(sym0)));
-            sum += (s[-1].Freq & (unsigned)(MASK(sym1)));
-            if (--num2 == 0)
-              break;
-          }
-        }
-
-        
-        R->Range /= sum;
-        RC_EncodeFinal(low, freq);
-        Ppmd7_Update2(p);
-        return;
-      }
-      sum += (s->Freq & (unsigned)(MASK(cur)));
-      s++;
-    }
-    while (--i);
-    
-    {
-      UInt32 total = sum + escFreq;
-      see->Summ = (UInt16)(see->Summ + total);
-
-      R->Range /= total;
-      RC_Encode(sum, escFreq);
-    }
-
-    {
-      CPpmd_State *s2 = Ppmd7_GetStats(p, p->MinContext);
-      s--;
-      MASK(s->Symbol) = 0;
-      do
-      {
-        unsigned sym0 = s2[0].Symbol;
-        unsigned sym1 = s2[1].Symbol;
-        s2 += 2;
-        MASK(sym0) = 0;
-        MASK(sym1) = 0;
-      }
-      while (s2 < s);
-    }
-  }
-}
-
-
-void Ppmd7z_EncodeSymbols(CPpmd7 *p, const Byte *buf, const Byte *lim)
-{
-  for (; buf < lim; buf++)
-  {
-    Ppmd7z_EncodeSymbol(p, *buf);
-  }
-}

3rdparty/7z/src/Precomp.h

@@ -1,10 +0,0 @@
-/* Precomp.h -- StdAfx
-2013-11-12 : Igor Pavlov : Public domain */
-
-#ifndef __7Z_PRECOMP_H
-#define __7Z_PRECOMP_H
-
-#include "Compiler.h"
-/* #include "7zTypes.h" */
-
-#endif

3rdparty/7z/src/RotateDefs.h

@@ -1,30 +0,0 @@
-/* RotateDefs.h -- Rotate functions
-2015-03-25 : Igor Pavlov : Public domain */
-
-#ifndef __ROTATE_DEFS_H
-#define __ROTATE_DEFS_H
-
-#ifdef _MSC_VER
-
-#include <stdlib.h>
-
-/* don't use _rotl with MINGW. It can insert slow call to function. */
- 
-/* #if (_MSC_VER >= 1200) */
-#pragma intrinsic(_rotl)
-#pragma intrinsic(_rotr)
-/* #endif */
-
-#define rotlFixed(x, n) _rotl((x), (n))
-#define rotrFixed(x, n) _rotr((x), (n))
-
-#else
-
-/* new compilers can translate these macros to fast commands. */
-
-#define rotlFixed(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
-#define rotrFixed(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
-
-#endif
-
-#endif