From d2a43b5080177a1d394fc2fb09fa07967eafdd8c Mon Sep 17 00:00:00 2001 From: ddidderr Date: Mon, 20 Jul 2026 12:04:17 +0200 Subject: [PATCH] refactor(compress): expose CCtx parameter leaves from Rust The three public CCtx parameter APIs were still implemented as C bodies that only forwarded into Rust symbols. Move ownership of those leaves to the Rust ABI by using the existing public C symbol names directly, while retaining the same signatures, behavior, and linker-visible API names. The neighboring C helpers remain because they carry C-owned configuration or private-state adaptation rather than being pure public forwarders. Test Plan: - `cargo +nightly fmt --manifest-path rust/Cargo.toml --all -- --check` -- passed. - `cc -fsyntax-only -Ilib -Icommon lib/compress/zstd_compress.c` -- passed. - `git diff --check` and `git diff --cached --check` -- passed. - Heavy cargo, make, and test commands were intentionally not run per scope. --- lib/compress/zstd_compress.c | 19 ------------------- rust/src/zstd_compress_params_api.rs | 18 +++++++++--------- 2 files changed, 9 insertions(+), 28 deletions(-) diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c index f2ffdcdbb..415d9dcb6 100644 --- a/lib/compress/zstd_compress.c +++ b/lib/compress/zstd_compress.c @@ -2001,7 +2001,6 @@ typedef char ZSTD_rust_select_block_compressor_state_layout[ /* CCtx parameter state is mirrored by rust/src/zstd_compress_params_api.rs. * Rust owns parameter bounds and clamping; C exposes only the * build-configuration values required by that narrow ABI. */ -ZSTD_bounds ZSTD_rust_cctx_params_get_bounds(int param); size_t ZSTD_rust_cctx_params_clamp_bounds(int param, int* value); int ZSTD_rust_cctx_params_within_bounds(int param, int value); int ZSTD_rust_cctx_params_is_multithreaded(void); @@ -2009,15 +2008,12 @@ int ZSTD_rust_cctx_params_nb_workers_max(void); int ZSTD_rust_cctx_params_job_size_min(void); int ZSTD_rust_cctx_params_job_size_max(void); ZSTD_CCtx_params* ZSTD_rust_createCCtxParams(ZSTD_customMem customMem); -size_t ZSTD_rust_freeCCtxParams(ZSTD_CCtx_params* params); void ZSTD_rust_makeCCtxParamsFromCParams( ZSTD_CCtx_params* cctxParams, const ZSTD_compressionParameters* cParams); void ZSTD_rust_CCtxParams_init_internal( ZSTD_CCtx_params* cctxParams, const ZSTD_parameters* params, int compressionLevel); -size_t ZSTD_rust_CCtxParams_init_advanced(ZSTD_CCtx_params* cctxParams, - ZSTD_parameters params); void ZSTD_rust_CCtxParams_setZstdParams(ZSTD_CCtx_params* cctxParams, const ZSTD_parameters* params); int ZSTD_useTargetCBlockSize(const ZSTD_CCtx_params* cctxParams); @@ -3584,11 +3580,6 @@ ZSTD_CCtx_params* ZSTD_createCCtxParams(void) return ZSTD_rust_createCCtxParams(ZSTD_defaultCMem); } -size_t ZSTD_freeCCtxParams(ZSTD_CCtx_params* params) -{ - return ZSTD_rust_freeCCtxParams(params); -} - #define ZSTD_NO_CLEVEL 0 /** @@ -3606,11 +3597,6 @@ ZSTD_CCtxParams_init_internal(ZSTD_CCtx_params* cctxParams, cctxParams->useRowMatchFinder, cctxParams->postBlockSplitter, cctxParams->ldmParams.enableLdm); } -size_t ZSTD_CCtxParams_init_advanced(ZSTD_CCtx_params* cctxParams, ZSTD_parameters params) -{ - return ZSTD_rust_CCtxParams_init_advanced(cctxParams, params); -} - /** * Sets cctxParams' cParams and fParams from params, but otherwise leaves them alone. * @param params Validated zstd parameters. @@ -3622,11 +3608,6 @@ static void ZSTD_CCtxParams_setZstdParams( ZSTD_rust_CCtxParams_setZstdParams(cctxParams, params); } -ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter param) -{ - return ZSTD_rust_cctx_params_get_bounds((int)param); -} - int ZSTD_rust_cctx_params_is_multithreaded(void) { #ifdef ZSTD_MULTITHREAD diff --git a/rust/src/zstd_compress_params_api.rs b/rust/src/zstd_compress_params_api.rs index 718dce4df..510607655 100644 --- a/rust/src/zstd_compress_params_api.rs +++ b/rust/src/zstd_compress_params_api.rs @@ -340,7 +340,7 @@ unsafe fn clamp_bounds(param: c_int, value: &mut c_int) -> usize { } #[no_mangle] -pub unsafe extern "C" fn ZSTD_rust_cctx_params_get_bounds(param: c_int) -> ZSTD_bounds { +pub unsafe extern "C" fn ZSTD_cParam_getBounds(param: c_int) -> ZSTD_bounds { unsafe { current_bounds(param) } } @@ -555,7 +555,7 @@ unsafe fn init_advanced_impl(params: *mut ZSTD_CCtx_params, zstd_params: ZSTD_pa } #[no_mangle] -pub unsafe extern "C" fn ZSTD_rust_CCtxParams_init_advanced( +pub unsafe extern "C" fn ZSTD_CCtxParams_init_advanced( params: *mut ZSTD_CCtx_params, zstd_params: ZSTD_parameters, ) -> usize { @@ -694,7 +694,7 @@ pub unsafe extern "C" fn ZSTD_rust_createCCtxParams( } #[no_mangle] -pub unsafe extern "C" fn ZSTD_rust_freeCCtxParams(params: *mut ZSTD_CCtx_params) -> usize { +pub unsafe extern "C" fn ZSTD_freeCCtxParams(params: *mut ZSTD_CCtx_params) -> usize { if params.is_null() { return 0; } @@ -1688,7 +1688,7 @@ mod tests { let params = storage.as_mut_ptr(); unsafe { (*params).customMem.opaque = ptr::dangling_mut::(); - assert_eq!(ZSTD_rust_CCtxParams_init_advanced(params, zstd_params), 0); + assert_eq!(ZSTD_CCtxParams_init_advanced(params, zstd_params), 0); assert_eq!((*params).cParams, zstd_params.cParams); assert_eq!((*params).fParams, zstd_params.fParams); assert_eq!((*params).compressionLevel, NO_CLEVEL); @@ -1720,7 +1720,7 @@ mod tests { fParams: ZSTD_frameParameters::default(), }; assert_eq!( - unsafe { ZSTD_rust_CCtxParams_init_advanced(ptr::null_mut(), valid_params) }, + unsafe { ZSTD_CCtxParams_init_advanced(ptr::null_mut(), valid_params) }, ERROR(ZstdErrorCode::Generic) ); @@ -1734,7 +1734,7 @@ mod tests { let mut invalid_params = valid_params; invalid_params.cParams.minMatch = 2; assert_eq!( - unsafe { ZSTD_rust_CCtxParams_init_advanced(params, invalid_params) }, + unsafe { ZSTD_CCtxParams_init_advanced(params, invalid_params) }, ERROR(ZstdErrorCode::ParameterOutOfBound) ); unsafe { @@ -1930,8 +1930,8 @@ mod tests { assert!(!params.is_null()); assert_eq!((*params).compressionLevel, DEFAULT_CLEVEL); assert_eq!((*params).fParams.contentSizeFlag, 1); - assert_eq!(ZSTD_rust_freeCCtxParams(params), 0); - assert_eq!(ZSTD_rust_freeCCtxParams(ptr::null_mut()), 0); + assert_eq!(ZSTD_freeCCtxParams(params), 0); + assert_eq!(ZSTD_freeCCtxParams(ptr::null_mut()), 0); let calls = AtomicUsize::new(0); let custom_mem = ZSTD_customMem { @@ -1943,7 +1943,7 @@ mod tests { assert!(!params.is_null()); assert_eq!((*params).customMem.opaque, custom_mem.opaque); assert_eq!(calls.load(Ordering::Relaxed), 1); - assert_eq!(ZSTD_rust_freeCCtxParams(params), 0); + assert_eq!(ZSTD_freeCCtxParams(params), 0); assert_eq!(calls.load(Ordering::Relaxed), 2); assert!(ZSTD_rust_createCCtxParams(ZSTD_customMem {