zstd-native-ruby 1.0.0 → 1.0.2

data/ext/zstd_native/zstd/build/cmake/CMakeLists.txt

@@ -0,0 +1,228 @@
+# ################################################################
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under both the BSD-style license (found in the
+# LICENSE file in the root directory of this source tree) and the GPLv2 (found
+# in the COPYING file in the root directory of this source tree).
+# ################################################################
+
+cmake_minimum_required(VERSION 3.10 FATAL_ERROR)
+
+# As of 2018-12-26 ZSTD has been validated to build with cmake version 3.13.2 new policies.
+# Set and use the newest cmake policies that are validated to work
+set(ZSTD_MAX_VALIDATED_CMAKE_MAJOR_VERSION "3")
+set(ZSTD_MAX_VALIDATED_CMAKE_MINOR_VERSION "13") #Policies never changed at PATCH level
+if("${ZSTD_MAX_VALIDATED_CMAKE_MAJOR_VERSION}" EQUAL "${CMAKE_MAJOR_VERSION}" AND
+       "${ZSTD_MAX_VALIDATED_CMAKE_MINOR_VERSION}" GREATER "${CMAKE_MINOR_VERSION}")
+    set(ZSTD_CMAKE_POLICY_VERSION "${CMAKE_VERSION}")
+else()
+    set(ZSTD_CMAKE_POLICY_VERSION "${ZSTD_MAX_VALIDATED_CMAKE_MAJOR_VERSION}.${ZSTD_MAX_VALIDATED_CMAKE_MINOR_VERSION}.0")
+endif()
+cmake_policy(VERSION ${ZSTD_CMAKE_POLICY_VERSION})
+
+set(CMAKE_BUILD_WITH_INSTALL_RPATH on)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules")
+set(ZSTD_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../..")
+set(LIBRARY_DIR ${ZSTD_SOURCE_DIR}/lib)
+# Parse version
+include(GetZstdLibraryVersion)
+GetZstdLibraryVersion(${LIBRARY_DIR}/zstd.h zstd_VERSION_MAJOR zstd_VERSION_MINOR zstd_VERSION_PATCH)
+
+set(ZSTD_SHORT_VERSION "${zstd_VERSION_MAJOR}.${zstd_VERSION_MINOR}")
+set(ZSTD_FULL_VERSION "${zstd_VERSION_MAJOR}.${zstd_VERSION_MINOR}.${zstd_VERSION_PATCH}")
+
+project(zstd
+  VERSION "${ZSTD_FULL_VERSION}"
+  LANGUAGES C   # Main library is in C
+            ASM # And ASM
+            CXX # Testing contributed code also utilizes CXX
+  )
+
+message(STATUS "ZSTD VERSION: ${zstd_VERSION}")
+set(zstd_HOMEPAGE_URL "https://facebook.github.io/zstd")
+set(zstd_DESCRIPTION  "Zstandard is a real-time compression algorithm, providing high compression ratios.")
+
+# Set a default build type if none was specified
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  message(STATUS "Setting build type to 'Release' as none was specified.")
+  set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
+  # Set the possible values of build type for cmake-gui
+  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
+endif()
+
+include(GNUInstallDirs)
+
+#-----------------------------------------------------------------------------
+# Add extra compilation flags
+#-----------------------------------------------------------------------------
+include(AddZstdCompilationFlags)
+ADD_ZSTD_COMPILATION_FLAGS()
+
+# Always hide XXHash symbols
+add_definitions(-DXXH_NAMESPACE=ZSTD_)
+
+#-----------------------------------------------------------------------------
+# Installation variables
+#-----------------------------------------------------------------------------
+message(STATUS "CMAKE_INSTALL_PREFIX: ${CMAKE_INSTALL_PREFIX}")
+message(STATUS "CMAKE_INSTALL_LIBDIR: ${CMAKE_INSTALL_LIBDIR}")
+
+#-----------------------------------------------------------------------------
+# Options
+#-----------------------------------------------------------------------------
+
+# Legacy support
+option(ZSTD_LEGACY_SUPPORT "LEGACY SUPPORT" ON)
+
+if (ZSTD_LEGACY_SUPPORT)
+    message(STATUS "ZSTD_LEGACY_SUPPORT defined!")
+    set(ZSTD_LEGACY_LEVEL 5 CACHE STRING "")
+    add_definitions(-DZSTD_LEGACY_SUPPORT=${ZSTD_LEGACY_LEVEL})
+else ()
+    message(STATUS "ZSTD_LEGACY_SUPPORT not defined!")
+    add_definitions(-DZSTD_LEGACY_SUPPORT=0)
+endif ()
+
+if (APPLE)
+    option(ZSTD_FRAMEWORK "Build as Apple Frameworks" OFF)
+endif ()
+
+if (ANDROID)
+    set(ZSTD_MULTITHREAD_SUPPORT_DEFAULT OFF)
+    # Old versions of bionic libc don't have fseeko/ftello
+    if ((NOT ${ANDROID_PLATFORM_LEVEL}) OR ${ANDROID_PLATFORM_LEVEL} VERSION_LESS 24)
+        message(STATUS "Setting compile definitions for old Android API")
+        add_compile_definitions(LIBC_NO_FSEEKO)
+    endif ()
+else()
+    set(ZSTD_MULTITHREAD_SUPPORT_DEFAULT ON)
+endif()
+
+# Multi-threading support
+option(ZSTD_MULTITHREAD_SUPPORT "MULTITHREADING SUPPORT" ${ZSTD_MULTITHREAD_SUPPORT_DEFAULT})
+
+if (ZSTD_MULTITHREAD_SUPPORT)
+    message(STATUS "ZSTD_MULTITHREAD_SUPPORT is enabled")
+else ()
+    message(STATUS "ZSTD_MULTITHREAD_SUPPORT is disabled")
+endif ()
+
+option(ZSTD_BUILD_PROGRAMS "BUILD PROGRAMS" ON)
+option(ZSTD_BUILD_CONTRIB "BUILD CONTRIB" OFF)
+
+# Respect the conventional CMake option for enabling tests if it was specified on the first configure
+if (BUILD_TESTING)
+    set(ZSTD_BUILD_TESTS_default ON)
+else()
+    set(ZSTD_BUILD_TESTS_default OFF)
+endif()
+option(ZSTD_BUILD_TESTS "BUILD TESTS" ${ZSTD_BUILD_TESTS_default})
+if (MSVC)
+    option(ZSTD_USE_STATIC_RUNTIME "LINK TO STATIC RUN-TIME LIBRARIES" OFF)
+endif ()
+
+#-----------------------------------------------------------------------------
+# External dependencies
+#-----------------------------------------------------------------------------
+# Define a function to handle special thread settings for HP-UX
+# See https://github.com/facebook/zstd/pull/3862 for details.
+function(setup_hpux_threads)
+    find_package(Threads)
+    if (NOT Threads_FOUND)
+        set(CMAKE_USE_PTHREADS_INIT 1 PARENT_SCOPE)
+        set(CMAKE_THREAD_LIBS_INIT -lpthread PARENT_SCOPE)
+        set(CMAKE_HAVE_THREADS_LIBRARY 1 PARENT_SCOPE)
+        set(Threads_FOUND TRUE PARENT_SCOPE)
+    endif()
+endfunction()
+
+if (ZSTD_MULTITHREAD_SUPPORT AND UNIX)
+    if (CMAKE_SYSTEM_NAME MATCHES "HP-UX")
+        setup_hpux_threads()
+    else()
+        set(THREADS_PREFER_PTHREAD_FLAG ON)
+        find_package(Threads REQUIRED)
+    endif()
+    if (CMAKE_USE_PTHREADS_INIT)
+        set(THREADS_LIBS "${CMAKE_THREAD_LIBS_INIT}")
+    else()
+        message(SEND_ERROR "ZSTD currently does not support thread libraries other than pthreads")
+    endif()
+endif ()
+
+#-----------------------------------------------------------------------------
+# Add source directories
+#-----------------------------------------------------------------------------
+add_subdirectory(lib)
+
+option(ZSTD_PROGRAMS_LINK_SHARED "PROGRAMS LINK SHARED" OFF)
+
+if (ZSTD_BUILD_PROGRAMS)
+    if (NOT ZSTD_BUILD_STATIC AND NOT ZSTD_PROGRAMS_LINK_SHARED)
+        message(SEND_ERROR "You need to build static library to build zstd CLI")
+    elseif(NOT ZSTD_BUILD_SHARED AND ZSTD_PROGRAMS_LINK_SHARED)
+        message(SEND_ERROR "You need to build shared library to build zstd CLI")
+    endif ()
+
+    add_subdirectory(programs)
+endif ()
+
+if (ZSTD_BUILD_TESTS)
+    enable_testing()
+    if (NOT ZSTD_BUILD_STATIC)
+        message(SEND_ERROR "You need to build static library to build tests")
+    endif ()
+
+    add_subdirectory(tests)
+endif ()
+
+if (ZSTD_BUILD_CONTRIB)
+    add_subdirectory(contrib)
+endif ()
+
+#-----------------------------------------------------------------------------
+# Add clean-all target
+#-----------------------------------------------------------------------------
+add_custom_target(clean-all
+   COMMAND ${CMAKE_BUILD_TOOL} clean
+   COMMAND rm -rf ${CMAKE_BINARY_DIR}/
+)
+
+#-----------------------------------------------------------------------------
+# Generate Package Config files
+#
+# This section is based on the boiler plate code from:
+# https://cmake.org/cmake/help/latest/manual/cmake-packages.7.html#creating-packages
+#-----------------------------------------------------------------------------
+include(CMakePackageConfigHelpers)
+write_basic_package_version_file(
+    "${CMAKE_CURRENT_BINARY_DIR}/zstdConfigVersion.cmake"
+    VERSION ${zstd_VERSION}
+    COMPATIBILITY SameMajorVersion
+    )
+
+# A Package Config file that works from the build directory
+export(EXPORT zstdExports
+    FILE "${CMAKE_CURRENT_BINARY_DIR}/zstdTargets.cmake"
+    NAMESPACE zstd::
+    )
+
+# A Package Config file that works from the installation directory
+set(ConfigPackageLocation ${CMAKE_INSTALL_LIBDIR}/cmake/zstd)
+install(EXPORT zstdExports
+    FILE zstdTargets.cmake
+    NAMESPACE zstd::
+    DESTINATION ${ConfigPackageLocation}
+    )
+configure_package_config_file(
+    zstdConfig.cmake.in
+    "${CMAKE_CURRENT_BINARY_DIR}/zstdConfig.cmake"
+    INSTALL_DESTINATION ${ConfigPackageLocation}
+)
+install(FILES
+    "${CMAKE_CURRENT_BINARY_DIR}/zstdConfig.cmake"
+    "${CMAKE_CURRENT_BINARY_DIR}/zstdConfigVersion.cmake"
+    DESTINATION ${ConfigPackageLocation}
+    )

data/{vendor → ext/zstd_native}/zstd/build/cmake/CMakeModules/AddZstdCompilationFlags.cmake

@@ -1,7 +1,5 @@
+include(CheckCXXCompilerFlag)
 include(CheckCCompilerFlag)
-if(CMAKE_CXX_COMPILER)
-    include(CheckCXXCompilerFlag)
-endif()
 
 if (CMAKE_VERSION VERSION_GREATER_EQUAL 3.18)
     set(ZSTD_HAVE_CHECK_LINKER_FLAG true)
@@ -23,7 +21,7 @@ function(EnableCompilerFlag _flag _C _CXX _LD)
             set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${_flag}" PARENT_SCOPE)
         endif ()
     endif ()
-    if (_CXX AND CMAKE_CXX_COMPILER)
+    if (_CXX)
         CHECK_CXX_COMPILER_FLAG(${_flag} CXX_FLAG_${varname})
         if (CXX_FLAG_${varname})
             set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${_flag}" PARENT_SCOPE)
@@ -51,7 +49,7 @@ function(EnableCompilerFlag _flag _C _CXX _LD)
     endif ()
 endfunction()
 
-macro(ADD_ZSTD_COMPILATION_FLAGS _C _CXX _LD)
+macro(ADD_ZSTD_COMPILATION_FLAGS)
     # We set ZSTD_HAS_NOEXECSTACK if we are certain we've set all the required
     # compiler flags to mark the stack as non-executable.
     set(ZSTD_HAS_NOEXECSTACK false)
@@ -65,26 +63,26 @@ macro(ADD_ZSTD_COMPILATION_FLAGS _C _CXX _LD)
         # EnableCompilerFlag("-std=c99" true false)   # Set C compilation to c99 standard
         if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND MSVC)
             # clang-cl normally maps -Wall to -Weverything.
-            EnableCompilerFlag("/clang:-Wall" _C _CXX false)
+            EnableCompilerFlag("/clang:-Wall" true true false)
         else ()
-            EnableCompilerFlag("-Wall" _C _CXX false)
+            EnableCompilerFlag("-Wall" true true false)
         endif ()
-        EnableCompilerFlag("-Wextra" _C _CXX false)
-        EnableCompilerFlag("-Wundef" _C _CXX false)
-        EnableCompilerFlag("-Wshadow" _C _CXX false)
-        EnableCompilerFlag("-Wcast-align" _C _CXX false)
-        EnableCompilerFlag("-Wcast-qual" _C _CXX false)
-        EnableCompilerFlag("-Wstrict-prototypes" _C false false)
+        EnableCompilerFlag("-Wextra" true true false)
+        EnableCompilerFlag("-Wundef" true true false)
+        EnableCompilerFlag("-Wshadow" true true false)
+        EnableCompilerFlag("-Wcast-align" true true false)
+        EnableCompilerFlag("-Wcast-qual" true true false)
+        EnableCompilerFlag("-Wstrict-prototypes" true false false)
         # Enable asserts in Debug mode
         if (CMAKE_BUILD_TYPE MATCHES "Debug")
-            EnableCompilerFlag("-DDEBUGLEVEL=1" _C _CXX false)
+            EnableCompilerFlag("-DDEBUGLEVEL=1" true true false)
         endif ()
         # Add noexecstack flags
         # LDFLAGS
-        EnableCompilerFlag("-Wl,-z,noexecstack" false false _LD)
+        EnableCompilerFlag("-Wl,-z,noexecstack" false false true)
         # CFLAGS & CXXFLAGS
-        EnableCompilerFlag("-Qunused-arguments" _C _CXX false)
-        EnableCompilerFlag("-Wa,--noexecstack" _C _CXX false)
+        EnableCompilerFlag("-Qunused-arguments" true true false)
+        EnableCompilerFlag("-Wa,--noexecstack" true true false)
         # NOTE: Using 3 nested ifs because the variables are sometimes
         # empty if the condition is false, and sometimes equal to false.
         # This implicitly converts them to truthy values. There may be
@@ -101,15 +99,15 @@ macro(ADD_ZSTD_COMPILATION_FLAGS _C _CXX _LD)
 
         set(ACTIVATE_MULTITHREADED_COMPILATION "ON" CACHE BOOL "activate multi-threaded compilation (/MP flag)")
         if (CMAKE_GENERATOR MATCHES "Visual Studio" AND ACTIVATE_MULTITHREADED_COMPILATION)
-            EnableCompilerFlag("/MP" _C _CXX false)
+            EnableCompilerFlag("/MP" true true false)
         endif ()
 
         # UNICODE SUPPORT
-        EnableCompilerFlag("/D_UNICODE" _C _CXX false)
-        EnableCompilerFlag("/DUNICODE" _C _CXX false)
+        EnableCompilerFlag("/D_UNICODE" true true false)
+        EnableCompilerFlag("/DUNICODE" true true false)
         # Enable asserts in Debug mode
         if (CMAKE_BUILD_TYPE MATCHES "Debug")
-            EnableCompilerFlag("/DDEBUGLEVEL=1" _C _CXX false)
+            EnableCompilerFlag("/DDEBUGLEVEL=1" true true false)
         endif ()
     endif ()
 

data/{vendor → ext/zstd_native}/zstd/build/cmake/README.md

@@ -7,15 +7,6 @@ variables.
 
 ## How to build
 
-You can configure the project from the repository root thanks to the forwarding
-`CMakeLists.txt`:
-```sh
-cmake -S . -B build-cmake
-cmake --build build-cmake
-```
-The historical workflow that starts configuration from `build/cmake` continues
-to work as described below.
-
 As cmake doesn't support command like `cmake clean`, it's recommended to perform an "out of source build".
 To do this, you can create a new directory and build in it:
 ```sh

data/{vendor → ext/zstd_native}/zstd/build/cmake/lib/CMakeLists.txt

@@ -7,7 +7,7 @@
 # in the COPYING file in the root directory of this source tree).
 # ################################################################
 
-project(libzstd C) # ASM language is conditionally enabled where supported
+project(libzstd C ASM)
 
 set(CMAKE_INCLUDE_CURRENT_DIR TRUE)
 option(ZSTD_BUILD_STATIC "BUILD STATIC LIBRARIES" ON)
@@ -40,7 +40,6 @@ if (MSVC)
     add_compile_options(-DZSTD_DISABLE_ASM)
 else ()
     if(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64.*|AMD64.*|x86_64.*|X86_64.*" AND ${ZSTD_HAS_NOEXECSTACK})
-        enable_language(ASM)
         set(DecompressSources ${DecompressSources} ${LIBRARY_DIR}/decompress/huf_decompress_amd64.S)
     else()
         add_compile_options(-DZSTD_DISABLE_ASM)
@@ -98,11 +97,9 @@ if (ZSTD_LEGACY_SUPPORT)
             ${LIBRARY_LEGACY_DIR}/zstd_v07.h)
 endif ()
 
-if (MSVC AND NOT (CMAKE_CXX_COMPILER_ID STREQUAL "Clang"))
+if (MSVC)
     set(MSVC_RESOURCE_DIR ${ZSTD_SOURCE_DIR}/build/VS2010/libzstd-dll)
     set(PlatformDependResources ${MSVC_RESOURCE_DIR}/libzstd-dll.rc)
-else()
-    set(PlatformDependResources)
 endif ()
 
 # Explicitly set the language to C for all files, including ASM files.
@@ -115,7 +112,7 @@ endif()
 
 macro (add_definition target var)
     if (NOT ("${${var}}" STREQUAL ""))
-        target_compile_definitions(${target} PUBLIC "${var}=__attribute__((visibility(\"${${var}}\")))")
+        set_property(TARGET ${target} APPEND PROPERTY COMPILE_DEFINITIONS "${var}=__attribute__((visibility(\"${${var}}\")))")
     endif ()
 endmacro ()
 
@@ -129,7 +126,7 @@ if (ZSTD_BUILD_SHARED)
     target_include_directories(libzstd_shared INTERFACE $<BUILD_INTERFACE:${PUBLIC_INCLUDE_DIRS}>)
     list(APPEND library_targets libzstd_shared)
     if (ZSTD_MULTITHREAD_SUPPORT)
-        target_compile_definitions(libzstd_shared PUBLIC ZSTD_MULTITHREAD)
+        set_property(TARGET libzstd_shared APPEND PROPERTY COMPILE_DEFINITIONS "ZSTD_MULTITHREAD")
         if (UNIX)
             target_link_libraries(libzstd_shared ${THREADS_LIBS})
         endif ()
@@ -143,7 +140,7 @@ if (ZSTD_BUILD_STATIC)
     target_include_directories(libzstd_static INTERFACE $<BUILD_INTERFACE:${PUBLIC_INCLUDE_DIRS}>)
     list(APPEND library_targets libzstd_static)
     if (ZSTD_MULTITHREAD_SUPPORT)
-        target_compile_definitions(libzstd_static PUBLIC ZSTD_MULTITHREAD)
+        set_property(TARGET libzstd_static APPEND PROPERTY COMPILE_DEFINITIONS "ZSTD_MULTITHREAD")
         if (UNIX)
             target_link_libraries(libzstd_static ${THREADS_LIBS})
         endif ()
@@ -210,7 +207,7 @@ if (ZSTD_BUILD_SHARED)
             OUTPUT_NAME zstd
             VERSION ${ZSTD_FULL_VERSION}
             SOVERSION ${zstd_VERSION_MAJOR})
-
+            
     if (ZSTD_FRAMEWORK)
         set_target_properties(
                 libzstd_shared

data/{vendor → ext/zstd_native}/zstd/build/meson/lib/meson.build

@@ -127,10 +127,6 @@ libzstd = library('zstd',
 libzstd_dep = declare_dependency(link_with: libzstd,
   include_directories: join_paths(zstd_rootdir,'lib')) # Do not expose private headers
 
-if meson.version().version_compare('>=0.54.0')
-  meson.override_dependency('libzstd', libzstd_dep)
-endif
-
 # we link to both:
 # - the shared library (for public symbols)
 # - the static library (for private symbols)

data/{vendor → ext/zstd_native}/zstd/build/meson/meson.build

@@ -10,7 +10,7 @@
 
 project('zstd',
   ['c', 'cpp'],
-  license: 'BSD-3-Clause OR GPL-2.0-only',
+  license: ['BSD', 'GPLv2'],
   default_options : [
     # There shouldn't be any need to force a C standard convention for zstd
     # but in case one would want that anyway, this can be done here.
@@ -65,6 +65,7 @@ zstd_docdir = join_paths(zstd_datadir, 'doc', meson.project_name())
 
 # Built-in options
 use_debug = get_option('debug')
+buildtype = get_option('buildtype')
 default_library_type = get_option('default_library')
 
 # Custom options

data/{vendor → ext/zstd_native}/zstd/contrib/externalSequenceProducer/main.c

@@ -27,7 +27,6 @@ do {                                                    \
 } while (0)                                             \
 
 int main(int argc, char *argv[]) {
-    int retn = 0;
     if (argc != 2) {
         printf("Usage: externalSequenceProducer <file>\n");
         return 1;
@@ -97,12 +96,12 @@ int main(int argc, char *argv[]) {
                 break;
             }
         }
-        retn = 1;
+        return 1;
     }
 
     ZSTD_freeCCtx(zc);
     free(src);
     free(dst);
     free(val);
-    return retn;
+    return 0;
 }

data/{vendor → ext/zstd_native}/zstd/contrib/largeNbDicts/largeNbDicts.c

@@ -739,8 +739,6 @@ static int benchMem(slice_collection_t dstBlocks, slice_collection_t srcBlocks,
     /* BMK_benchTimedFn may not run exactly nbRounds iterations */
     double speedAggregated =
         aggregateData(speedPerRound, roundNb + 1, metricAggregatePref);
-    free(speedPerRound);
-    
     if (metricAggregatePref == fastest)
       DISPLAY("Fastest Speed : %.1f MB/s \n", speedAggregated);
     else

data/{vendor → ext/zstd_native}/zstd/contrib/linux-kernel/linux_zstd.h

@@ -77,30 +77,6 @@ int zstd_min_clevel(void);
  */
 int zstd_max_clevel(void);
 
-/**
- * zstd_default_clevel() - default compression level
- *
- * Return: Default compression level.
- */
-int zstd_default_clevel(void);
-
-/**
- * struct zstd_custom_mem - custom memory allocation
- */
-typedef ZSTD_customMem zstd_custom_mem;
-
-/**
- * struct zstd_dict_load_method - Dictionary load method.
- * See zstd_lib.h.
- */
-typedef ZSTD_dictLoadMethod_e zstd_dict_load_method;
-
-/**
- * struct zstd_dict_content_type - Dictionary context type.
- * See zstd_lib.h.
- */
-typedef ZSTD_dictContentType_e zstd_dict_content_type;
-
 /* ======   Parameter Selection   ====== */
 
 /**
@@ -160,18 +136,6 @@ typedef ZSTD_parameters zstd_parameters;
 zstd_parameters zstd_get_params(int level,
 	unsigned long long estimated_src_size);
 
-/**
- * zstd_get_cparams() - returns zstd_compression_parameters for selected level
- * @level:              The compression level
- * @estimated_src_size: The estimated source size to compress or 0
- *                      if unknown.
- * @dict_size:          Dictionary size.
- *
- * Return:              The selected zstd_compression_parameters.
- */
-zstd_compression_parameters zstd_get_cparams(int level,
-	unsigned long long estimated_src_size, size_t dict_size);
-
 typedef ZSTD_CCtx zstd_cctx;
 typedef ZSTD_cParameter zstd_cparameter;
 
@@ -241,71 +205,6 @@ zstd_cctx *zstd_init_cctx(void *workspace, size_t workspace_size);
 size_t zstd_compress_cctx(zstd_cctx *cctx, void *dst, size_t dst_capacity,
 	const void *src, size_t src_size, const zstd_parameters *parameters);
 
-/**
- * zstd_create_cctx_advanced() - Create compression context
- * @custom_mem:   Custom allocator.
- *
- * Return:        NULL on error, pointer to compression context otherwise.
- */
-zstd_cctx *zstd_create_cctx_advanced(zstd_custom_mem custom_mem);
-
-/**
- * zstd_free_cctx() - Free compression context
- * @cdict:        Pointer to compression context.
- *
- * Return:        Always 0.
- */
-size_t zstd_free_cctx(zstd_cctx* cctx);
-
-/**
- * struct zstd_cdict - Compression dictionary.
- * See zstd_lib.h.
- */
-typedef ZSTD_CDict zstd_cdict;
-
-/**
- * zstd_create_cdict_byreference() - Create compression dictionary
- * @dict:              Pointer to dictionary buffer.
- * @dict_size:         Size of the dictionary buffer.
- * @dict_load_method:  Dictionary load method.
- * @dict_content_type: Dictionary content type.
- * @custom_mem:        Memory allocator.
- *
- * Note, this uses @dict by reference (ZSTD_dlm_byRef), so it should be
- * free before zstd_cdict is destroyed.
- *
- * Return:             NULL on error, pointer to compression dictionary
- *                     otherwise.
- */
-zstd_cdict *zstd_create_cdict_byreference(const void *dict, size_t dict_size,
-					  zstd_compression_parameters cparams,
-					  zstd_custom_mem custom_mem);
-
-/**
- * zstd_free_cdict() - Free compression dictionary
- * @cdict:        Pointer to compression dictionary.
- *
- * Return:        Always 0.
- */
-size_t zstd_free_cdict(zstd_cdict* cdict);
-
-/**
- * zstd_compress_using_cdict() - compress src into dst using a dictionary
- * @cctx:         The context. Must have been initialized with zstd_init_cctx().
- * @dst:          The buffer to compress src into.
- * @dst_capacity: The size of the destination buffer. May be any size, but
- *                ZSTD_compressBound(srcSize) is guaranteed to be large enough.
- * @src:          The data to compress.
- * @src_size:     The size of the data to compress.
- * @cdict:        The dictionary to be used.
- *
- * Return:        The compressed size or an error, which can be checked using
- *                zstd_is_error().
- */
-size_t zstd_compress_using_cdict(zstd_cctx *cctx, void *dst,
-	size_t dst_capacity, const void *src, size_t src_size,
-	const zstd_cdict *cdict);
-
 /* ======   Single-pass Decompression   ====== */
 
 typedef ZSTD_DCtx zstd_dctx;
@@ -346,71 +245,6 @@ zstd_dctx *zstd_init_dctx(void *workspace, size_t workspace_size);
 size_t zstd_decompress_dctx(zstd_dctx *dctx, void *dst, size_t dst_capacity,
 	const void *src, size_t src_size);
 
-/**
- * struct zstd_ddict - Decompression dictionary.
- * See zstd_lib.h.
- */
-typedef ZSTD_DDict zstd_ddict;
-
-/**
- * zstd_create_ddict_byreference() - Create decompression dictionary
- * @dict:              Pointer to dictionary buffer.
- * @dict_size:         Size of the dictionary buffer.
- * @dict_load_method:  Dictionary load method.
- * @dict_content_type: Dictionary content type.
- * @custom_mem:        Memory allocator.
- *
- * Note, this uses @dict by reference (ZSTD_dlm_byRef), so it should be
- * free before zstd_ddict is destroyed.
- *
- * Return:             NULL on error, pointer to decompression dictionary
- *                     otherwise.
- */
-zstd_ddict *zstd_create_ddict_byreference(const void *dict, size_t dict_size,
-					  zstd_custom_mem custom_mem);
-/**
- * zstd_free_ddict() - Free decompression dictionary
- * @dict:         Pointer to the dictionary.
- *
- * Return:        Always 0.
- */
-size_t zstd_free_ddict(zstd_ddict *ddict);
-
-/**
- * zstd_create_dctx_advanced() - Create decompression context
- * @custom_mem:   Custom allocator.
- *
- * Return:        NULL on error, pointer to decompression context otherwise.
- */
-zstd_dctx *zstd_create_dctx_advanced(zstd_custom_mem custom_mem);
-
-/**
- * zstd_free_dctx() -- Free decompression context
- * @dctx:         Pointer to decompression context.
- * Return:        Always 0.
- */
-size_t zstd_free_dctx(zstd_dctx *dctx);
-
-/**
- * zstd_decompress_using_ddict() - decompress src into dst using a dictionary
- * @dctx:         The decompression context.
- * @dst:          The buffer to decompress src into.
- * @dst_capacity: The size of the destination buffer. Must be at least as large
- *                as the decompressed size. If the caller cannot upper bound the
- *                decompressed size, then it's better to use the streaming API.
- * @src:          The zstd compressed data to decompress. Multiple concatenated
- *                frames and skippable frames are allowed.
- * @src_size:     The exact size of the data to decompress.
- * @ddict:        The dictionary to be used.
- *
- * Return:        The decompressed size or an error, which can be checked using
- *                zstd_is_error().
- */
-size_t zstd_decompress_using_ddict(zstd_dctx *dctx,
-	void *dst, size_t dst_capacity, const void *src, size_t src_size,
-	const zstd_ddict *ddict);
-
-
 /* ======   Streaming Buffers   ====== */
 
 /**