From eec065c0b7d3a86887c15426428f9c58c0b9b21e Mon Sep 17 00:00:00 2001 From: Mattias Wallin Date: Fri, 5 Jun 2026 15:50:02 +0200 Subject: [PATCH 01/16] Fix clippy::borrow_as_ptr --- programs/benchfn.rs | 6 +- programs/benchzstd.rs | 72 +++------- programs/datagen.rs | 13 +- programs/dibio.rs | 10 +- programs/fileio.rs | 204 ++++++++++++++-------------- programs/fileio_asyncio.rs | 59 ++++---- programs/main.rs | 1 + programs/timefn.rs | 2 +- programs/util.rs | 54 ++++---- programs/zstdcli.rs | 267 +++++++++++++++++++------------------ programs/zstdcli_trace.rs | 4 +- 11 files changed, 330 insertions(+), 362 deletions(-) diff --git a/programs/benchfn.rs b/programs/benchfn.rs index f79738f0..08ad4908 100644 --- a/programs/benchfn.rs +++ b/programs/benchfn.rs @@ -88,11 +88,7 @@ unsafe fn BMK_runOutcome_error(errorResult: size_t) -> BMK_runOutcome_t { error_result_never_ever_use_directly: 0, error_tag_never_ever_use_directly: 0, }; - ptr::write_bytes( - &mut b as *mut BMK_runOutcome_t as *mut u8, - 0, - size_of::(), - ); + ptr::write_bytes(&raw mut b as *mut u8, 0, size_of::()); b.error_tag_never_ever_use_directly = 1; b.error_result_never_ever_use_directly = errorResult; b diff --git a/programs/benchzstd.rs b/programs/benchzstd.rs index 01da310d..4b31da1f 100644 --- a/programs/benchzstd.rs +++ b/programs/benchzstd.rs @@ -720,7 +720,7 @@ unsafe fn local_defaultDecompress( if out.pos == out.size { return -(ZSTD_error_dstSize_tooSmall as core::ffi::c_int) as size_t; } - moreToFlush = ZSTD_decompressStream(dctx, &mut out, &mut in_0); + moreToFlush = ZSTD_decompressStream(dctx, &raw mut out, &raw mut in_0); if ZSTD_isError(moreToFlush) != 0 { return moreToFlush; } @@ -744,11 +744,7 @@ unsafe fn BMK_benchOutcome_error() -> BMK_benchOutcome_t { }, tag: 0, }; - ptr::write_bytes( - &mut b as *mut BMK_benchOutcome_t as *mut u8, - 0, - size_of::(), - ); + ptr::write_bytes(&raw mut b as *mut u8, 0, size_of::()); b.tag = 1; b } @@ -815,7 +811,7 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( assert!(!cctx.is_null()); assert!(!dctx.is_null()); ptr::write_bytes( - &mut benchResult as *mut BMK_benchResult_t as *mut u8, + &raw mut benchResult as *mut u8, 0, size_of::(), ); @@ -842,11 +838,7 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( }, tag: 0, }; - ptr::write_bytes( - &mut r as *mut BMK_benchOutcome_t as *mut u8, - 0, - size_of::(), - ); + ptr::write_bytes(&raw mut r as *mut u8, 0, size_of::()); if displayLevel >= 1 { fprintf( stderr, @@ -880,11 +872,7 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( }, tag: 0, }; - ptr::write_bytes( - &mut r_0 as *mut BMK_benchOutcome_t as *mut u8, - 0, - size_of::(), - ); + ptr::write_bytes(&raw mut r_0 as *mut u8, 0, size_of::()); if displayLevel >= 1 { fprintf( stderr, @@ -925,11 +913,7 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( }, tag: 0, }; - ptr::write_bytes( - &mut r_1 as *mut BMK_benchOutcome_t as *mut u8, - 0, - size_of::(), - ); + ptr::write_bytes(&raw mut r_1 as *mut u8, 0, size_of::()); if displayLevel >= 1 { fprintf( stderr, @@ -964,11 +948,7 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( }, tag: 0, }; - ptr::write_bytes( - &mut r_2 as *mut BMK_benchOutcome_t as *mut u8, - 0, - size_of::(), - ); + ptr::write_bytes(&raw mut r_2 as *mut u8, 0, size_of::()); if displayLevel >= 1 { fprintf( stderr, @@ -1139,7 +1119,7 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( ); cbp.benchPayload = cctx as *mut core::ffi::c_void; cbp.initFn = Some(local_initCCtx as unsafe fn(*mut core::ffi::c_void) -> size_t); - cbp.initPayload = &mut cctxprep as *mut BMK_initCCtxArgs as *mut core::ffi::c_void; + cbp.initPayload = &raw mut cctxprep as *mut core::ffi::c_void; cbp.errorFn = Some(ZSTD_isError as unsafe extern "C" fn(size_t) -> core::ffi::c_uint); cbp.blockCount = nbChunks as size_t; cbp.srcBuffers = srcPtrs; @@ -1165,7 +1145,7 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( ); dbp.benchPayload = dctx as *mut core::ffi::c_void; dbp.initFn = Some(local_initDCtx as unsafe fn(*mut core::ffi::c_void) -> size_t); - dbp.initPayload = &mut dctxprep as *mut BMK_initDCtxArgs as *mut core::ffi::c_void; + dbp.initPayload = &raw mut dctxprep as *mut core::ffi::c_void; dbp.errorFn = Some(ZSTD_isError as unsafe extern "C" fn(size_t) -> core::ffi::c_uint); dbp.blockCount = nbChunks as size_t; dbp.srcBuffers = cPtrs as *const *const core::ffi::c_void; @@ -1208,11 +1188,7 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( }, tag: 0, }; - ptr::write_bytes( - &mut r_3 as *mut BMK_benchOutcome_t as *mut u8, - 0, - size_of::(), - ); + ptr::write_bytes(&raw mut r_3 as *mut u8, 0, size_of::()); if displayLevel >= 1 { fprintf( stderr, @@ -1288,11 +1264,7 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( }, tag: 0, }; - ptr::write_bytes( - &mut r_4 as *mut BMK_benchOutcome_t as *mut u8, - 0, - size_of::(), - ); + ptr::write_bytes(&raw mut r_4 as *mut u8, 0, size_of::()); if displayLevel >= 1 { fprintf( stderr, @@ -1616,7 +1588,7 @@ pub unsafe fn BMK_benchMemAdvanced( cSizes, resPtrs, resSizes, - &mut resultBuffer, + &raw mut resultBuffer, compressedBuffer, maxCompressedSize, timeStateCompress, @@ -1659,11 +1631,7 @@ pub unsafe fn BMK_benchMemAdvanced( }, tag: 0, }; - ptr::write_bytes( - &mut r as *mut BMK_benchOutcome_t as *mut u8, - 0, - size_of::(), - ); + ptr::write_bytes(&raw mut r as *mut u8, 0, size_of::()); if displayLevel >= 1 { fprintf( stderr, @@ -1696,11 +1664,7 @@ pub unsafe fn BMK_benchMemAdvanced( }, tag: 0, }; - ptr::write_bytes( - &mut r_0 as *mut BMK_benchOutcome_t as *mut u8, - 0, - size_of::(), - ); + ptr::write_bytes(&raw mut r_0 as *mut u8, 0, size_of::()); if displayLevel >= 1 { fprintf( stderr, @@ -1751,7 +1715,7 @@ pub unsafe fn BMK_benchMem( dictBufferSize, displayLevel, displayName, - &adv, + &raw const adv, ) } unsafe fn BMK_benchCLevels( @@ -1886,7 +1850,7 @@ pub unsafe fn BMK_syntheticTest( let res = BMK_benchCLevels( srcBuffer, benchedSize, - &benchedSize, + &raw const benchedSize, 1, startingCLevel, endCLevel, @@ -2144,7 +2108,7 @@ pub unsafe fn BMK_benchFilesAdvanced( dictBuffer, dictBufferSize, fileSizes, - &dictFileName, + &raw const dictFileName, 1, displayLevel, ); @@ -2245,6 +2209,6 @@ pub unsafe fn BMK_benchFiles( cLevel, compressionParams, displayLevel, - &adv, + &raw const adv, ) } diff --git a/programs/datagen.rs b/programs/datagen.rs index 21c856cf..768c2aad 100644 --- a/programs/datagen.rs +++ b/programs/datagen.rs @@ -162,7 +162,14 @@ pub unsafe fn RDG_genBuffer( ldt.as_mut_ptr(), (litProba * 256.0 + 0.001f64) as fixedPoint_24_8, ); - RDG_genBlock(buffer, size, 0, matchProba, ldt.as_mut_ptr(), &mut seed32); + RDG_genBlock( + buffer, + size, + 0, + matchProba, + ldt.as_mut_ptr(), + &raw mut seed32, + ); } pub unsafe fn RDG_genStdout( size: core::ffi::c_ulonglong, @@ -194,7 +201,7 @@ pub unsafe fn RDG_genStdout( 0, matchProba, ldt.as_mut_ptr(), - &mut seed32, + &raw mut seed32, ); while (total as core::ffi::c_ulonglong) < size { let genBlockSize = (if (stdBlockSize as core::ffi::c_ulonglong) @@ -210,7 +217,7 @@ pub unsafe fn RDG_genStdout( stdDictSize, matchProba, ldt.as_mut_ptr(), - &mut seed32, + &raw mut seed32, ); total = total.wrapping_add(genBlockSize as u64); let _ = fwrite(buff as *const core::ffi::c_void, 1, genBlockSize, stdout); diff --git a/programs/dibio.rs b/programs/dibio.rs index 10baa31b..85c3daf5 100644 --- a/programs/dibio.rs +++ b/programs/dibio.rs @@ -218,7 +218,7 @@ unsafe fn DiB_shuffle(fileNamesTable: *mut *const core::ffi::c_char, nbFiles: co } i = nbFiles.wrapping_sub(1); while i > 0 { - let j = (DiB_rand(&mut seed)).wrapping_rem(i.wrapping_add(1)); + let j = (DiB_rand(&raw mut seed)).wrapping_rem(i.wrapping_add(1)); let tmp = *fileNamesTable.offset(j as isize); let fresh2 = &mut (*fileNamesTable.offset(j as isize)); *fresh2 = *fileNamesTable.offset(i as isize); @@ -320,11 +320,7 @@ unsafe fn DiB_fileStats( oneSampleTooLarge: 0, }; let mut n: core::ffi::c_int = 0; - ptr::write_bytes( - &mut fs as *mut fileStats as *mut u8, - 0, - size_of::(), - ); + ptr::write_bytes(&raw mut fs as *mut u8, 0, size_of::()); n = 0; while n < nbFiles { let fileSize = DiB_getFileSize(*fileNamesTable.offset(n as isize)); @@ -559,7 +555,7 @@ pub unsafe fn DiB_trainFromFiles( } nbSamplesLoaded = DiB_loadFiles( srcBuffer, - &mut loadedSize, + &raw mut loadedSize, sampleSizes, fs.nbSamples, fileNamesTable, diff --git a/programs/fileio.rs b/programs/fileio.rs index df86f2b9..1caf07d7 100644 --- a/programs/fileio.rs +++ b/programs/fileio.rs @@ -736,7 +736,7 @@ unsafe fn FIO_removeFile(path: *const core::ffi::c_char) -> core::ffi::c_int { }, __glibc_reserved: [0; 3], }; - if UTIL_stat(path, &mut statbuf) == 0 { + if UTIL_stat(path, &raw mut statbuf) == 0 { if g_display_prefs.displayLevel >= 2 { fprintf( stderr, @@ -747,7 +747,7 @@ unsafe fn FIO_removeFile(path: *const core::ffi::c_char) -> core::ffi::c_int { } return 0; } - if UTIL_isRegularFileStat(&statbuf) == 0 { + if UTIL_isRegularFileStat(&raw const statbuf) == 0 { if g_display_prefs.displayLevel >= 2 { fprintf( stderr, @@ -1042,7 +1042,7 @@ unsafe fn FIO_setDictBufferMalloc( ) -> size_t { let mut fileHandle = core::ptr::null_mut::(); let mut fileSize: size_t = 0; - let bufferPtr: *mut *mut core::ffi::c_void = &mut (*dict).dictBuffer; + let bufferPtr: *mut *mut core::ffi::c_void = &raw mut (*dict).dictBuffer; assert!(!bufferPtr.is_null()); assert!(!dictFileStat.is_null()); *bufferPtr = core::ptr::null_mut(); @@ -1196,7 +1196,7 @@ unsafe fn FIO_setDictBufferMMap( ) -> size_t { let mut fileHandle: core::ffi::c_int = 0; let mut fileSize: u64 = 0; - let bufferPtr: *mut *mut core::ffi::c_void = &mut (*dict).dictBuffer; + let bufferPtr: *mut *mut core::ffi::c_void = &raw mut (*dict).dictBuffer; assert!(!bufferPtr.is_null()); assert!(!dictFileStat.is_null()); *bufferPtr = core::ptr::null_mut(); @@ -1486,7 +1486,7 @@ unsafe fn FIO_createFilename_fromOutDir( } else { memcpy( result.add(strlen(outDirName)) as *mut core::ffi::c_void, - &mut separator as *mut core::ffi::c_char as *const core::ffi::c_void, + &raw mut separator as *const core::ffi::c_void, 1, ); memcpy( @@ -1923,11 +1923,7 @@ unsafe fn FIO_createCResources( writeCtx: core::ptr::null_mut::(), readCtx: core::ptr::null_mut::(), }; - ptr::write_bytes( - &mut ress as *mut cRess_t as *mut u8, - 0, - size_of::(), - ); + ptr::write_bytes(&raw mut ress as *mut u8, 0, size_of::()); if g_display_prefs.displayLevel >= 6 { fprintf( stderr, @@ -1965,14 +1961,14 @@ unsafe fn FIO_createCResources( } exit(30); } - FIO_getDictFileStat(dictFileName, &mut ress.dictFileStat); + FIO_getDictFileStat(dictFileName, &raw mut ress.dictFileStat); if (*prefs).patchFromMode != 0 { - let dictSize = UTIL_getFileSizeStat(&ress.dictFileStat); + let dictSize = UTIL_getFileSizeStat(&raw const ress.dictFileStat); let ssSize = (*prefs).streamSrcSize as core::ffi::c_ulonglong; useMMap |= (dictSize > (*prefs).memLimit as u64) as core::ffi::c_int; FIO_adjustParamsForPatchFromMode( prefs, - &mut comprParams, + &raw mut comprParams, dictSize as core::ffi::c_ulonglong, if ssSize > 0 { ssSize } else { maxSrcFileSize }, cLevel, @@ -1984,10 +1980,10 @@ unsafe fn FIO_createCResources( FIO_mallocDict as core::ffi::c_int }) as FIO_dictBufferType_t; FIO_initDict( - &mut ress.dict, + &raw mut ress.dict, dictFileName, prefs, - &mut ress.dictFileStat, + &raw mut ress.dictFileStat, dictBufferType, ); ress.writeCtx = AIO_WritePool_create(prefs, ZSTD_CStreamOutSize()); @@ -3252,7 +3248,7 @@ unsafe fn FIO_createCResources( ress } unsafe fn FIO_freeCResources(ress: *mut cRess_t) { - FIO_freeDict(&mut (*ress).dict); + FIO_freeDict(&raw mut (*ress).dict); AIO_WritePool_free((*ress).writeCtx); AIO_ReadPool_free((*ress).readCtx); ZSTD_freeCStream((*ress).cctx); @@ -3290,7 +3286,7 @@ unsafe fn FIO_compressGzFrame( strm.zfree = None; strm.opaque = core::ptr::null_mut(); let ret = deflateInit2_( - &mut strm, + &raw mut strm, compressionLevel, 8, 15 + 16, @@ -3349,7 +3345,7 @@ unsafe fn FIO_compressGzFrame( strm.avail_in = (*(*ress).readCtx).srcBufferLoaded as uInt; } let availBefore = strm.avail_in as size_t; - ret_0 = deflate(&mut strm, Z_NO_FLUSH); + ret_0 = deflate(&raw mut strm, Z_NO_FLUSH); AIO_ReadPool_consumeBytes( (*ress).readCtx, availBefore.wrapping_sub(strm.avail_in as size_t), @@ -3389,7 +3385,7 @@ unsafe fn FIO_compressGzFrame( let cSize = ((*writeJob).bufferSize).wrapping_sub(strm.avail_out as size_t); if cSize != 0 { (*writeJob).usedBufferSize = cSize; - AIO_WritePool_enqueueAndReacquireWriteJob(&mut writeJob); + AIO_WritePool_enqueueAndReacquireWriteJob(&raw mut writeJob); outFileSize = outFileSize.wrapping_add(cSize as core::ffi::c_ulonglong); strm.next_out = (*writeJob).buffer as *mut Bytef; strm.avail_out = (*writeJob).bufferSize as uInt; @@ -3442,11 +3438,11 @@ unsafe fn FIO_compressGzFrame( } } loop { - let ret_1 = deflate(&mut strm, Z_FINISH); + let ret_1 = deflate(&raw mut strm, Z_FINISH); let cSize_0 = ((*writeJob).bufferSize).wrapping_sub(strm.avail_out as size_t); if cSize_0 != 0 { (*writeJob).usedBufferSize = cSize_0; - AIO_WritePool_enqueueAndReacquireWriteJob(&mut writeJob); + AIO_WritePool_enqueueAndReacquireWriteJob(&raw mut writeJob); outFileSize = outFileSize.wrapping_add(cSize_0 as core::ffi::c_ulonglong); strm.next_out = (*writeJob).buffer as *mut Bytef; strm.avail_out = (*writeJob).bufferSize as uInt; @@ -3487,7 +3483,7 @@ unsafe fn FIO_compressGzFrame( exit(77); } } - let ret_2 = deflateEnd(&mut strm); + let ret_2 = deflateEnd(&raw mut strm); if ret_2 != Z_OK { if g_display_prefs.displayLevel >= 1 { fprintf(stderr, b"zstd: \0" as *const u8 as *const core::ffi::c_char); @@ -3593,7 +3589,7 @@ unsafe fn FIO_compressLzmaFrame( reserved_ptr1: core::ptr::null_mut::(), reserved_ptr2: core::ptr::null_mut::(), }; - if lzma_lzma_preset(&mut opt_lzma, compressionLevel as u32) != 0 { + if lzma_lzma_preset(&raw mut opt_lzma, compressionLevel as u32) != 0 { if g_display_prefs.displayLevel >= 1 { fprintf(stderr, b"zstd: \0" as *const u8 as *const core::ffi::c_char); } @@ -3624,7 +3620,7 @@ unsafe fn FIO_compressLzmaFrame( } exit(81); } - ret = lzma_alone_encoder(&mut strm, &opt_lzma); + ret = lzma_alone_encoder(&raw mut strm, &raw const opt_lzma); if ret as core::ffi::c_uint != LZMA_OK as core::ffi::c_int as core::ffi::c_uint { if g_display_prefs.displayLevel >= 1 { fprintf(stderr, b"zstd: \0" as *const u8 as *const core::ffi::c_char); @@ -3659,7 +3655,7 @@ unsafe fn FIO_compressLzmaFrame( exit(82); } } else { - ret = lzma_easy_encoder(&mut strm, compressionLevel as u32, LZMA_CHECK_CRC64); + ret = lzma_easy_encoder(&raw mut strm, compressionLevel as u32, LZMA_CHECK_CRC64); if ret as core::ffi::c_uint != LZMA_OK as core::ffi::c_int as core::ffi::c_uint { if g_display_prefs.displayLevel >= 1 { fprintf(stderr, b"zstd: \0" as *const u8 as *const core::ffi::c_char); @@ -3710,7 +3706,7 @@ unsafe fn FIO_compressLzmaFrame( strm.avail_in = (*(*ress).readCtx).srcBufferLoaded; } let availBefore = strm.avail_in; - ret = lzma_code(&mut strm, action); + ret = lzma_code(&raw mut strm, action); AIO_ReadPool_consumeBytes((*ress).readCtx, availBefore.wrapping_sub(strm.avail_in)); if ret as core::ffi::c_uint != LZMA_OK as core::ffi::c_int as core::ffi::c_uint && ret as core::ffi::c_uint != LZMA_STREAM_END as core::ffi::c_int as core::ffi::c_uint @@ -3750,7 +3746,7 @@ unsafe fn FIO_compressLzmaFrame( let compBytes = ((*writeJob).bufferSize).wrapping_sub(strm.avail_out); if compBytes != 0 { (*writeJob).usedBufferSize = compBytes; - AIO_WritePool_enqueueAndReacquireWriteJob(&mut writeJob); + AIO_WritePool_enqueueAndReacquireWriteJob(&raw mut writeJob); outFileSize = outFileSize.wrapping_add(compBytes as core::ffi::c_ulonglong); strm.next_out = (*writeJob).buffer as *mut u8; strm.avail_out = (*writeJob).bufferSize; @@ -3805,7 +3801,7 @@ unsafe fn FIO_compressLzmaFrame( break; } } - lzma_end(&mut strm); + lzma_end(&raw mut strm); *readsize = inFileSize as u64; AIO_WritePool_releaseIoJob(writeJob); AIO_WritePool_sparseWriteEnd((*ress).writeCtx); @@ -3956,7 +3952,11 @@ unsafe fn FIO_compressZstdFrame( suffix: core::ptr::null::(), }; let mut err_1: size_t = 0; - err_1 = ZSTD_CCtx_getParameter(ress.cctx, ZSTD_cParameter::ZSTD_c_windowLog, &mut windowLog); + err_1 = ZSTD_CCtx_getParameter( + ress.cctx, + ZSTD_cParameter::ZSTD_c_windowLog, + &raw mut windowLog, + ); if ZSTD_isError(err_1) != 0 { if g_display_prefs.displayLevel >= 5 { fprintf( @@ -4056,7 +4056,8 @@ unsafe fn FIO_compressZstdFrame( let oldIPos = inBuff.pos; let mut outBuff = setOutBuffer((*writeJob).buffer, (*writeJob).bufferSize, 0); let toFlushNow = ZSTD_toFlushNow(ress.cctx); - stillToFlush = ZSTD_compressStream2(ress.cctx, &mut outBuff, &mut inBuff, directive); + stillToFlush = + ZSTD_compressStream2(ress.cctx, &raw mut outBuff, &raw mut inBuff, directive); if ZSTD_isError(stillToFlush) != 0 { if g_display_prefs.displayLevel >= 5 { fprintf( @@ -4118,7 +4119,7 @@ unsafe fn FIO_compressZstdFrame( } if outBuff.pos != 0 { (*writeJob).usedBufferSize = outBuff.pos; - AIO_WritePool_enqueueAndReacquireWriteJob(&mut writeJob); + AIO_WritePool_enqueueAndReacquireWriteJob(&raw mut writeJob); compressedfilesize = compressedfilesize.wrapping_add(outBuff.pos as u64); } if (*prefs).adaptiveMode != 0 && UTIL_clockSpanMicro(lastAdaptTime) > adaptEveryMicro { @@ -4486,20 +4487,20 @@ unsafe fn FIO_compressFilename_internal( match (*prefs).compressionType as core::ffi::c_uint { 1 => { compressedfilesize = FIO_compressGzFrame( - &ress, + &raw const ress, srcFileName, fileSize, compressionLevel, - &mut readsize, + &raw mut readsize, ) as u64; } 2 | 3 => { compressedfilesize = FIO_compressLzmaFrame( - &mut ress, + &raw mut ress, srcFileName, fileSize, compressionLevel, - &mut readsize, + &raw mut readsize, ((*prefs).compressionType as core::ffi::c_uint == FIO_lzmaCompression as core::ffi::c_int as core::ffi::c_uint) as core::ffi::c_int, @@ -4541,11 +4542,11 @@ unsafe fn FIO_compressFilename_internal( compressedfilesize = FIO_compressZstdFrame( fCtx, prefs, - &ress, + &raw const ress, srcFileName, fileSize, compressionLevel, - &mut readsize, + &raw mut readsize, ) as u64; } } @@ -4870,9 +4871,10 @@ unsafe fn FIO_compressFilename_srcFile( srcFileName, ); } - if strcmp(srcFileName, stdinmark.as_ptr()) != 0 && UTIL_stat(srcFileName, &mut srcFileStat) != 0 + if strcmp(srcFileName, stdinmark.as_ptr()) != 0 + && UTIL_stat(srcFileName, &raw mut srcFileStat) != 0 { - if UTIL_isDirectoryStat(&srcFileStat) != 0 { + if UTIL_isDirectoryStat(&raw const srcFileStat) != 0 { if g_display_prefs.displayLevel >= 1 { fprintf( stderr, @@ -4887,8 +4889,8 @@ unsafe fn FIO_compressFilename_srcFile( && UTIL_isSameFileStat( srcFileName, ress.dictFileName, - &srcFileStat, - &ress.dictFileStat, + &raw const srcFileStat, + &raw const ress.dictFileStat, ) != 0 { if g_display_prefs.displayLevel >= 1 { @@ -4914,12 +4916,12 @@ unsafe fn FIO_compressFilename_srcFile( } return 0; } - srcFile = FIO_openSrcFile(prefs, srcFileName, &mut srcFileStat); + srcFile = FIO_openSrcFile(prefs, srcFileName, &raw mut srcFileStat); if srcFile.is_null() { return 1; } if strcmp(srcFileName, stdinmark.as_ptr()) != 0 { - fileSize = UTIL_getFileSizeStat(&srcFileStat); + fileSize = UTIL_getFileSizeStat(&raw const srcFileStat); } if fileSize != UTIL_FILESIZE_UNKNOWN as u64 && fileSize < (ZSTD_BLOCKSIZE_MAX * 3) as u64 { AIO_ReadPool_setAsync(ress.readCtx, 0); @@ -4935,7 +4937,7 @@ unsafe fn FIO_compressFilename_srcFile( ress, dstFileName, srcFileName, - &srcFileStat, + &raw const srcFileStat, compressionLevel, ); AIO_ReadPool_closeFile(ress.readCtx); @@ -5122,7 +5124,7 @@ pub unsafe fn FIO_compressFilename( srcFileName, compressionLevel, ); - FIO_freeCResources(&mut ress); + FIO_freeCResources(&raw mut ress); result } unsafe fn FIO_determineCompressedName( @@ -5247,7 +5249,7 @@ pub unsafe fn FIO_compressMultipleFilenames( // output into a single destination (stdout typically) let mut dstFile = core::ptr::null_mut::(); if FIO_multiFilesConcatWarning(fCtx, prefs, outFileName, 1) != 0 { - FIO_freeCResources(&mut ress); + FIO_freeCResources(&raw mut ress); return 1; } dstFile = FIO_openDstFile( @@ -5405,7 +5407,7 @@ pub unsafe fn FIO_compressMultipleFilenames( } } - FIO_freeCResources(&mut ress); + FIO_freeCResources(&raw mut ress); error } unsafe fn FIO_createDResources( @@ -5451,19 +5453,11 @@ unsafe fn FIO_createDResources( writeCtx: core::ptr::null_mut::(), readCtx: core::ptr::null_mut::(), }; - ptr::write_bytes( - &mut statbuf as *mut stat_t as *mut u8, - 0, - size_of::(), - ); - ptr::write_bytes( - &mut ress as *mut dRess_t as *mut u8, - 0, - size_of::(), - ); - FIO_getDictFileStat(dictFileName, &mut statbuf); + ptr::write_bytes(&raw mut statbuf as *mut u8, 0, size_of::()); + ptr::write_bytes(&raw mut ress as *mut u8, 0, size_of::()); + FIO_getDictFileStat(dictFileName, &raw mut statbuf); if (*prefs).patchFromMode != 0 { - let dictSize = UTIL_getFileSizeStat(&statbuf); + let dictSize = UTIL_getFileSizeStat(&raw const statbuf); useMMap |= (dictSize > (*prefs).memLimit as u64) as core::ffi::c_int; FIO_adjustMemLimitForPatchFromMode(prefs, dictSize as core::ffi::c_ulonglong, 0); } @@ -5587,10 +5581,10 @@ unsafe fn FIO_createDResources( FIO_mallocDict as core::ffi::c_int }) as FIO_dictBufferType_t; FIO_initDict( - &mut ress.dict, + &raw mut ress.dict, dictFileName, prefs, - &mut statbuf, + &raw mut statbuf, dictBufferType, ); let mut err_1: size_t = 0; @@ -5728,7 +5722,7 @@ unsafe fn FIO_createDResources( ress } unsafe fn FIO_freeDResources(mut ress: dRess_t) { - FIO_freeDict(&mut ress.dict); + FIO_freeDict(&raw mut ress.dict); let mut err: size_t = 0; err = ZSTD_freeDStream(ress.dctx); if ZSTD_isError(err) != 0 { @@ -5804,7 +5798,7 @@ unsafe fn FIO_passThrough(ress: *mut dRess_t) -> core::ffi::c_int { writeSize, ); (*writeJob).usedBufferSize = writeSize; - AIO_WritePool_enqueueAndReacquireWriteJob(&mut writeJob); + AIO_WritePool_enqueueAndReacquireWriteJob(&raw mut writeJob); AIO_ReadPool_consumeBytes((*ress).readCtx, writeSize); AIO_ReadPool_fillBuffer((*ress).readCtx, blockSize); } @@ -5836,7 +5830,7 @@ unsafe fn FIO_zstdErrorHelp( return; } err = ZSTD_getFrameHeader( - &mut header, + &raw mut header, (*(*ress).readCtx).srcBuffer as *const core::ffi::c_void, (*(*ress).readCtx).srcBufferLoaded, ); @@ -5916,7 +5910,7 @@ unsafe fn FIO_decompressZstdFrame( 0, ); let mut outBuff = setOutBuffer((*writeJob).buffer, (*writeJob).bufferSize, 0); - let readSizeHint = ZSTD_decompressStream((*ress).dctx, &mut outBuff, &mut inBuff); + let readSizeHint = ZSTD_decompressStream((*ress).dctx, &raw mut outBuff, &raw mut inBuff); let hrs = UTIL_makeHumanReadableSize(alreadyDecoded.wrapping_add(frameSize)); if ZSTD_isError(readSizeHint) != 0 { if g_display_prefs.displayLevel >= 1 { @@ -5932,7 +5926,7 @@ unsafe fn FIO_decompressZstdFrame( return FIO_ERROR_FRAME_DECODING as core::ffi::c_ulonglong; } (*writeJob).usedBufferSize = outBuff.pos; - AIO_WritePool_enqueueAndReacquireWriteJob(&mut writeJob); + AIO_WritePool_enqueueAndReacquireWriteJob(&raw mut writeJob); frameSize = frameSize.wrapping_add(outBuff.pos as u64); if (*fCtx).nbFilesTotal > 1 { if g_display_prefs.progressSetting as core::ffi::c_uint @@ -6045,7 +6039,7 @@ unsafe fn FIO_decompressGzFrame( strm.next_in = core::ptr::null_mut::(); strm.avail_in = 0; if inflateInit2_( - &mut strm, + &raw mut strm, 15 + 16, ZLIB_VERSION.as_ptr(), size_of::() as core::ffi::c_int, @@ -6068,7 +6062,7 @@ unsafe fn FIO_decompressGzFrame( strm.next_in = (*(*ress).readCtx).srcBuffer as *mut core::ffi::c_uchar; strm.avail_in = (*(*ress).readCtx).srcBufferLoaded as uInt; } - ret = inflate(&mut strm, flush); + ret = inflate(&raw mut strm, flush); if ret == Z_BUF_ERROR { if g_display_prefs.displayLevel >= 1 { fprintf( @@ -6094,7 +6088,7 @@ unsafe fn FIO_decompressGzFrame( let decompBytes = ((*writeJob).bufferSize).wrapping_sub(strm.avail_out as size_t); if decompBytes != 0 { (*writeJob).usedBufferSize = decompBytes; - AIO_WritePool_enqueueAndReacquireWriteJob(&mut writeJob); + AIO_WritePool_enqueueAndReacquireWriteJob(&raw mut writeJob); outFileSize = outFileSize.wrapping_add(decompBytes as core::ffi::c_ulonglong); strm.next_out = (*writeJob).buffer as *mut Bytef; strm.avail_out = (*writeJob).bufferSize as uInt; @@ -6108,7 +6102,7 @@ unsafe fn FIO_decompressGzFrame( (*ress).readCtx, ((*(*ress).readCtx).srcBufferLoaded).wrapping_sub(strm.avail_in as size_t), ); - if inflateEnd(&mut strm) != Z_OK && decodingError == 0 { + if inflateEnd(&raw mut strm) != Z_OK && decodingError == 0 { if g_display_prefs.displayLevel >= 1 { fprintf( stderr, @@ -6161,9 +6155,9 @@ unsafe fn FIO_decompressLzmaFrame( strm.next_in = core::ptr::null::(); strm.avail_in = 0; if plain_lzma != 0 { - initRet = lzma_alone_decoder(&mut strm, UINT64_MAX); + initRet = lzma_alone_decoder(&raw mut strm, UINT64_MAX); } else { - initRet = lzma_stream_decoder(&mut strm, UINT64_MAX, 0); + initRet = lzma_stream_decoder(&raw mut strm, UINT64_MAX, 0); } if initRet as core::ffi::c_uint != LZMA_OK as core::ffi::c_int as core::ffi::c_uint { if g_display_prefs.displayLevel >= 1 { @@ -6196,7 +6190,7 @@ unsafe fn FIO_decompressLzmaFrame( strm.next_in = (*(*ress).readCtx).srcBuffer as *const u8; strm.avail_in = (*(*ress).readCtx).srcBufferLoaded; } - ret = lzma_code(&mut strm, action); + ret = lzma_code(&raw mut strm, action); if ret as core::ffi::c_uint == LZMA_BUF_ERROR as core::ffi::c_int as core::ffi::c_uint { if g_display_prefs.displayLevel >= 1 { fprintf( @@ -6225,7 +6219,7 @@ unsafe fn FIO_decompressLzmaFrame( let decompBytes = ((*writeJob).bufferSize).wrapping_sub(strm.avail_out); if decompBytes != 0 { (*writeJob).usedBufferSize = decompBytes; - AIO_WritePool_enqueueAndReacquireWriteJob(&mut writeJob); + AIO_WritePool_enqueueAndReacquireWriteJob(&raw mut writeJob); outFileSize = outFileSize.wrapping_add(decompBytes as core::ffi::c_ulonglong); strm.next_out = (*writeJob).buffer as *mut u8; strm.avail_out = (*writeJob).bufferSize; @@ -6240,7 +6234,7 @@ unsafe fn FIO_decompressLzmaFrame( (*ress).readCtx, ((*(*ress).readCtx).srcBufferLoaded).wrapping_sub(strm.avail_in), ); - lzma_end(&mut strm); + lzma_end(&raw mut strm); AIO_WritePool_releaseIoJob(writeJob); AIO_WritePool_sparseWriteEnd((*ress).writeCtx); if decodingError != 0 { @@ -6286,7 +6280,7 @@ unsafe fn FIO_decompressFrames( readSomething = 1; if (*ress.readCtx).srcBufferLoaded < toRead { if passThrough != 0 { - return FIO_passThrough(&mut ress); + return FIO_passThrough(&raw mut ress); } if g_display_prefs.displayLevel >= 1 { fprintf( @@ -6302,8 +6296,13 @@ unsafe fn FIO_decompressFrames( (*ress.readCtx).srcBufferLoaded, ) != 0 { - let frameSize = - FIO_decompressZstdFrame(fCtx, &mut ress, prefs, srcFileName, filesize as u64); + let frameSize = FIO_decompressZstdFrame( + fCtx, + &raw mut ress, + prefs, + srcFileName, + filesize as u64, + ); if frameSize == FIO_ERROR_FRAME_DECODING as core::ffi::c_ulonglong { return 1; } @@ -6311,7 +6310,7 @@ unsafe fn FIO_decompressFrames( } else if *buf.offset(0) as core::ffi::c_int == 31 && *buf.offset(1) as core::ffi::c_int == 139 { - let frameSize_0 = FIO_decompressGzFrame(&mut ress, srcFileName); + let frameSize_0 = FIO_decompressGzFrame(&raw mut ress, srcFileName); if frameSize_0 == FIO_ERROR_FRAME_DECODING as core::ffi::c_ulonglong { return 1; } @@ -6322,7 +6321,7 @@ unsafe fn FIO_decompressFrames( && *buf.offset(1) as core::ffi::c_int == 0 { let frameSize_1 = FIO_decompressLzmaFrame( - &mut ress, + &raw mut ress, srcFileName, (*buf.offset(0) as core::ffi::c_int != 0xfd as core::ffi::c_int) as core::ffi::c_int, @@ -6342,7 +6341,7 @@ unsafe fn FIO_decompressFrames( } return 1; } else if passThrough != 0 { - return FIO_passThrough(&mut ress); + return FIO_passThrough(&raw mut ress); } else { if g_display_prefs.displayLevel >= 1 { fprintf( @@ -6487,12 +6486,12 @@ unsafe fn FIO_decompressSrcFile( } return 1; } - srcFile = FIO_openSrcFile(prefs, srcFileName, &mut srcFileStat); + srcFile = FIO_openSrcFile(prefs, srcFileName, &raw mut srcFileStat); if srcFile.is_null() { return 1; } if strcmp(srcFileName, stdinmark.as_ptr()) != 0 { - fileSize = UTIL_getFileSizeStat(&srcFileStat); + fileSize = UTIL_getFileSizeStat(&raw const srcFileStat); } if fileSize != UTIL_FILESIZE_UNKNOWN as u64 && fileSize < (ZSTD_BLOCKSIZE_MAX * 3) as u64 { AIO_ReadPool_setAsync(ress.readCtx, 0); @@ -6502,7 +6501,14 @@ unsafe fn FIO_decompressSrcFile( AIO_WritePool_setAsync(ress.writeCtx, 1); } AIO_ReadPool_setFile(ress.readCtx, srcFile); - result = FIO_decompressDstFile(fCtx, prefs, ress, dstFileName, srcFileName, &srcFileStat); + result = FIO_decompressDstFile( + fCtx, + prefs, + ress, + dstFileName, + srcFileName, + &raw const srcFileStat, + ); AIO_ReadPool_setFile(ress.readCtx, core::ptr::null_mut()); if fclose(srcFile) != 0 { if g_display_prefs.displayLevel >= 1 { @@ -6925,7 +6931,7 @@ unsafe fn FIO_analyzeFrames(info: *mut fileInfo_t, srcFile: *mut FILE) -> InfoEr ((*info).decompressedSize).wrapping_add(frameContentSize); } if ZSTD_getFrameHeader( - &mut header, + &raw mut header, headerBuffer.as_mut_ptr() as *const core::ffi::c_void, numBytesRead, ) != 0 @@ -7134,7 +7140,7 @@ unsafe fn getFileInfo_fileConfirmed( }, __glibc_reserved: [0; 3], }; - let srcFile = FIO_openSrcFile(core::ptr::null(), inFileName, &mut srcFileStat); + let srcFile = FIO_openSrcFile(core::ptr::null(), inFileName, &raw mut srcFileStat); if srcFile.is_null() { if g_display_prefs.displayLevel >= 1 { fprintf( @@ -7148,7 +7154,7 @@ unsafe fn getFileInfo_fileConfirmed( } return info_file_error; } - (*info).compressedSize = UTIL_getFileSizeStat(&srcFileStat); + (*info).compressedSize = UTIL_getFileSizeStat(&raw const srcFileStat); status = FIO_analyzeFrames(info, srcFile); fclose(srcFile); (*info).nbFiles = 1; @@ -7308,11 +7314,7 @@ unsafe fn FIO_addFInfo(fi1: fileInfo_t, fi2: fileInfo_t) -> fileInfo_t { nbFiles: 0, dictID: 0, }; - ptr::write_bytes( - &mut total as *mut fileInfo_t as *mut u8, - 0, - size_of::(), - ); + ptr::write_bytes(&raw mut total as *mut u8, 0, size_of::()); total.numActualFrames = fi1.numActualFrames + fi2.numActualFrames; total.numSkippableFrames = fi1.numSkippableFrames + fi2.numSkippableFrames; total.compressedSize = (fi1.compressedSize).wrapping_add(fi2.compressedSize); @@ -7339,12 +7341,8 @@ unsafe fn FIO_listFile( nbFiles: 0, dictID: 0, }; - ptr::write_bytes( - &mut info as *mut fileInfo_t as *mut u8, - 0, - size_of::(), - ); - let error = getFileInfo(&mut info, inFileName); + ptr::write_bytes(&raw mut info as *mut u8, 0, size_of::()); + let error = getFileInfo(&raw mut info, inFileName); match error as core::ffi::c_uint { 1 => { if g_display_prefs.displayLevel >= 1 { @@ -7385,7 +7383,7 @@ unsafe fn FIO_listFile( } 0 | _ => {} } - displayInfo(inFileName, &info, displayLevel); + displayInfo(inFileName, &raw const info, displayLevel); *total = FIO_addFInfo(*total, info); assert!( error as core::ffi::c_uint == info_success as core::ffi::c_int as core::ffi::c_uint @@ -7457,17 +7455,13 @@ pub unsafe fn FIO_listMultipleFiles( nbFiles: 0, dictID: 0, }; - ptr::write_bytes( - &mut total as *mut fileInfo_t as *mut u8, - 0, - size_of::(), - ); + ptr::write_bytes(&raw mut total as *mut u8, 0, size_of::()); total.usesCheck = 1; let mut u_0: core::ffi::c_uint = 0; u_0 = 0; while u_0 < numFiles { error |= FIO_listFile( - &mut total, + &raw mut total, *filenameTable.offset(u_0 as isize), displayLevel, ); diff --git a/programs/fileio_asyncio.rs b/programs/fileio_asyncio.rs index 8d75e8c4..d2025a56 100644 --- a/programs/fileio_asyncio.rs +++ b/programs/fileio_asyncio.rs @@ -498,7 +498,7 @@ unsafe fn AIO_IOPool_createThreadPool(ctx: *mut IOPoolCtx_t, prefs: *const FIO_p (*ctx).threadPoolActive = 0; if (*prefs).asyncIO != 0 { if pthread_mutex_init( - &mut (*ctx).ioJobsMutex, + &raw mut (*ctx).ioJobsMutex, core::ptr::null::(), ) != 0 { @@ -596,12 +596,12 @@ unsafe fn AIO_IOPool_threadPoolActive(ctx: *mut IOPoolCtx_t) -> core::ffi::c_int } unsafe fn AIO_IOPool_lockJobsMutex(ctx: *mut IOPoolCtx_t) { if AIO_IOPool_threadPoolActive(ctx) != 0 { - pthread_mutex_lock(&mut (*ctx).ioJobsMutex); + pthread_mutex_lock(&raw mut (*ctx).ioJobsMutex); } } unsafe fn AIO_IOPool_unlockJobsMutex(ctx: *mut IOPoolCtx_t) { if AIO_IOPool_threadPoolActive(ctx) != 0 { - pthread_mutex_unlock(&mut (*ctx).ioJobsMutex); + pthread_mutex_unlock(&raw mut (*ctx).ioJobsMutex); } } unsafe fn AIO_IOPool_releaseIoJob(job: *mut IOJob_t) { @@ -633,7 +633,7 @@ unsafe fn AIO_IOPool_destroy(ctx: *mut IOPoolCtx_t) { AIO_IOPool_join(ctx); assert!((*ctx).availableJobsCount == (*ctx).totalIoJobs); POOL_free((*ctx).threadPool); - pthread_mutex_destroy(&mut (*ctx).ioJobsMutex); + pthread_mutex_destroy(&raw mut (*ctx).ioJobsMutex); } assert!(((*ctx).file).is_null()); i = 0; @@ -681,7 +681,7 @@ unsafe fn AIO_IOPool_enqueueJob(job: *mut IOJob_t) { } } pub unsafe fn AIO_WritePool_acquireJob(ctx: *mut WritePoolCtx_t) -> *mut IOJob_t { - AIO_IOPool_acquireJob(&mut (*ctx).base) + AIO_IOPool_acquireJob(&raw mut (*ctx).base) } pub unsafe fn AIO_WritePool_enqueueAndReacquireWriteJob(job: *mut *mut IOJob_t) { AIO_IOPool_enqueueJob(*job); @@ -689,16 +689,16 @@ pub unsafe fn AIO_WritePool_enqueueAndReacquireWriteJob(job: *mut *mut IOJob_t) } pub unsafe fn AIO_WritePool_sparseWriteEnd(ctx: *mut WritePoolCtx_t) { assert!(!ctx.is_null()); - AIO_IOPool_join(&mut (*ctx).base); + AIO_IOPool_join(&raw mut (*ctx).base); AIO_fwriteSparseEnd((*ctx).base.prefs, (*ctx).base.file, (*ctx).storedSkips); (*ctx).storedSkips = 0; } pub unsafe fn AIO_WritePool_setFile(ctx: *mut WritePoolCtx_t, file: *mut FILE) { - AIO_IOPool_setFile(&mut (*ctx).base, file); + AIO_IOPool_setFile(&raw mut (*ctx).base, file); assert!((*ctx).storedSkips == 0); } pub unsafe fn AIO_WritePool_getFile(ctx: *const WritePoolCtx_t) -> *mut FILE { - AIO_IOPool_getFile(&(*ctx).base) + AIO_IOPool_getFile(&raw const (*ctx).base) } pub unsafe fn AIO_WritePool_releaseIoJob(job: *mut IOJob_t) { AIO_IOPool_releaseIoJob(job); @@ -707,7 +707,7 @@ pub unsafe fn AIO_WritePool_closeFile(ctx: *mut WritePoolCtx_t) -> core::ffi::c_ let dstFile = (*ctx).base.file; assert!(!dstFile.is_null() || (*(*ctx).base.prefs).testMode != 0); AIO_WritePool_sparseWriteEnd(ctx); - AIO_IOPool_setFile(&mut (*ctx).base, core::ptr::null_mut()); + AIO_IOPool_setFile(&raw mut (*ctx).base, core::ptr::null_mut()); fclose(dstFile) } unsafe fn AIO_WritePool_executeWriteJob(opaque: *mut core::ffi::c_void) { @@ -758,7 +758,7 @@ pub unsafe fn AIO_WritePool_create( exit(100); } AIO_IOPool_init( - &mut (*ctx).base, + &raw mut (*ctx).base, prefs, AIO_WritePool_executeWriteJob, bufferSize, @@ -770,12 +770,12 @@ pub unsafe fn AIO_WritePool_free(ctx: *mut WritePoolCtx_t) { if !(AIO_WritePool_getFile(ctx)).is_null() { AIO_WritePool_closeFile(ctx); } - AIO_IOPool_destroy(&mut (*ctx).base); + AIO_IOPool_destroy(&raw mut (*ctx).base); assert!((*ctx).storedSkips == 0); free(ctx as *mut core::ffi::c_void); } pub unsafe fn AIO_WritePool_setAsync(ctx: *mut WritePoolCtx_t, async_0: core::ffi::c_int) { - AIO_IOPool_setThreaded(&mut (*ctx).base, async_0); + AIO_IOPool_setThreaded(&raw mut (*ctx).base, async_0); } unsafe fn AIO_ReadPool_releaseAllCompletedJobs(ctx: *mut ReadPoolCtx_t) { let mut i: core::ffi::c_int = 0; @@ -789,16 +789,16 @@ unsafe fn AIO_ReadPool_releaseAllCompletedJobs(ctx: *mut ReadPoolCtx_t) { } unsafe fn AIO_ReadPool_addJobToCompleted(job: *mut IOJob_t) { let ctx = (*job).ctx as *mut ReadPoolCtx_t; - AIO_IOPool_lockJobsMutex(&mut (*ctx).base); + AIO_IOPool_lockJobsMutex(&raw mut (*ctx).base); assert!((*ctx).completedJobsCount < MAX_IO_JOBS); let fresh3 = (*ctx).completedJobsCount; (*ctx).completedJobsCount += 1; let fresh4 = &mut (*((*ctx).completedJobs).as_mut_ptr().offset(fresh3 as isize)); *fresh4 = job as *mut core::ffi::c_void; - if AIO_IOPool_threadPoolActive(&mut (*ctx).base) != 0 { - pthread_cond_signal(&mut (*ctx).jobCompletedCond); + if AIO_IOPool_threadPoolActive(&raw mut (*ctx).base) != 0 { + pthread_cond_signal(&raw mut (*ctx).jobCompletedCond); } - AIO_IOPool_unlockJobsMutex(&mut (*ctx).base); + AIO_IOPool_unlockJobsMutex(&raw mut (*ctx).base); } unsafe fn AIO_ReadPool_findNextWaitingOffsetCompletedJob_locked( ctx: *mut ReadPoolCtx_t, @@ -827,11 +827,14 @@ unsafe fn AIO_ReadPool_numReadsInFlight(ctx: *mut ReadPoolCtx_t) -> size_t { } unsafe fn AIO_ReadPool_getNextCompletedJob(ctx: *mut ReadPoolCtx_t) -> *mut IOJob_t { let mut job = core::ptr::null_mut(); - AIO_IOPool_lockJobsMutex(&mut (*ctx).base); + AIO_IOPool_lockJobsMutex(&raw mut (*ctx).base); job = AIO_ReadPool_findNextWaitingOffsetCompletedJob_locked(ctx); while job.is_null() && AIO_ReadPool_numReadsInFlight(ctx) > 0 { assert!(!((*ctx).base.threadPool).is_null()); - pthread_cond_wait(&mut (*ctx).jobCompletedCond, &mut (*ctx).base.ioJobsMutex); + pthread_cond_wait( + &raw mut (*ctx).jobCompletedCond, + &raw mut (*ctx).base.ioJobsMutex, + ); job = AIO_ReadPool_findNextWaitingOffsetCompletedJob_locked(ctx); } if !job.is_null() { @@ -840,7 +843,7 @@ unsafe fn AIO_ReadPool_getNextCompletedJob(ctx: *mut ReadPoolCtx_t) -> *mut IOJo .waitingOnOffset .wrapping_add((*job).usedBufferSize as u64); } - AIO_IOPool_unlockJobsMutex(&mut (*ctx).base); + AIO_IOPool_unlockJobsMutex(&raw mut (*ctx).base); job } unsafe fn AIO_ReadPool_executeReadJob(opaque: *mut core::ffi::c_void) { @@ -918,7 +921,7 @@ unsafe fn AIO_ReadPool_executeReadJob(opaque: *mut core::ffi::c_void) { AIO_ReadPool_addJobToCompleted(job); } unsafe fn AIO_ReadPool_enqueueRead(ctx: *mut ReadPoolCtx_t) { - let job = AIO_IOPool_acquireJob(&mut (*ctx).base); + let job = AIO_IOPool_acquireJob(&raw mut (*ctx).base); (*job).offset = (*ctx).nextReadOffset; (*ctx).nextReadOffset = (*ctx).nextReadOffset.wrapping_add((*job).bufferSize as u64); AIO_IOPool_enqueueJob(job); @@ -931,13 +934,13 @@ unsafe fn AIO_ReadPool_startReading(ctx: *mut ReadPoolCtx_t) { } pub unsafe fn AIO_ReadPool_setFile(ctx: *mut ReadPoolCtx_t, file: *mut FILE) { assert!(!ctx.is_null()); - AIO_IOPool_join(&mut (*ctx).base); + AIO_IOPool_join(&raw mut (*ctx).base); AIO_ReadPool_releaseAllCompletedJobs(ctx); if !((*ctx).currentJobHeld).is_null() { AIO_IOPool_releaseIoJob((*ctx).currentJobHeld as *mut IOJob_t); (*ctx).currentJobHeld = core::ptr::null_mut(); } - AIO_IOPool_setFile(&mut (*ctx).base, file); + AIO_IOPool_setFile(&raw mut (*ctx).base, file); (*ctx).nextReadOffset = 0; (*ctx).waitingOnOffset = 0; (*ctx).srcBuffer = (*ctx).coalesceBuffer; @@ -983,7 +986,7 @@ pub unsafe fn AIO_ReadPool_create( exit(100); } AIO_IOPool_init( - &mut (*ctx).base, + &raw mut (*ctx).base, prefs, AIO_ReadPool_executeReadJob, bufferSize, @@ -1025,7 +1028,7 @@ pub unsafe fn AIO_ReadPool_create( (*ctx).currentJobHeld = core::ptr::null_mut(); if !((*ctx).base.threadPool).is_null() && pthread_cond_init( - &mut (*ctx).jobCompletedCond, + &raw mut (*ctx).jobCompletedCond, core::ptr::null::(), ) != 0 { @@ -1065,9 +1068,9 @@ pub unsafe fn AIO_ReadPool_free(ctx: *mut ReadPoolCtx_t) { AIO_ReadPool_closeFile(ctx); } if !((*ctx).base.threadPool).is_null() { - pthread_cond_destroy(&mut (*ctx).jobCompletedCond); + pthread_cond_destroy(&raw mut (*ctx).jobCompletedCond); } - AIO_IOPool_destroy(&mut (*ctx).base); + AIO_IOPool_destroy(&raw mut (*ctx).base); free((*ctx).coalesceBuffer as *mut core::ffi::c_void); free(ctx as *mut core::ffi::c_void); } @@ -1129,7 +1132,7 @@ pub unsafe fn AIO_ReadPool_consumeAndRefill(ctx: *mut ReadPoolCtx_t) -> size_t { AIO_ReadPool_fillBuffer(ctx, (*ctx).base.jobBufferSize) } pub unsafe fn AIO_ReadPool_getFile(ctx: *const ReadPoolCtx_t) -> *mut FILE { - AIO_IOPool_getFile(&(*ctx).base) + AIO_IOPool_getFile(&raw const (*ctx).base) } pub unsafe fn AIO_ReadPool_closeFile(ctx: *mut ReadPoolCtx_t) -> core::ffi::c_int { let file = AIO_ReadPool_getFile(ctx); @@ -1137,5 +1140,5 @@ pub unsafe fn AIO_ReadPool_closeFile(ctx: *mut ReadPoolCtx_t) -> core::ffi::c_in fclose(file) } pub unsafe fn AIO_ReadPool_setAsync(ctx: *mut ReadPoolCtx_t, async_0: core::ffi::c_int) { - AIO_IOPool_setThreaded(&mut (*ctx).base, async_0); + AIO_IOPool_setThreaded(&raw mut (*ctx).base, async_0); } diff --git a/programs/main.rs b/programs/main.rs index 13e4a240..e0d4d086 100644 --- a/programs/main.rs +++ b/programs/main.rs @@ -5,6 +5,7 @@ #![allow(unused_assignments)] // FIXME I guess #![allow(clippy::all)] +#![warn(clippy::borrow_as_ptr)] extern crate libc; pub mod benchfn; diff --git a/programs/timefn.rs b/programs/timefn.rs index 40ace8f8..76c2ee55 100644 --- a/programs/timefn.rs +++ b/programs/timefn.rs @@ -8,7 +8,7 @@ pub struct UTIL_time_t { } pub unsafe fn UTIL_getTime() -> UTIL_time_t { let mut time = core::mem::zeroed::(); - if clock_gettime(CLOCK_MONOTONIC, &mut time) != 0 { + if clock_gettime(CLOCK_MONOTONIC, &raw mut time) != 0 { perror( b"timefn::clock_gettime(CLOCK_MONOTONIC)\0" as *const u8 as *const core::ffi::c_char, ); diff --git a/programs/util.rs b/programs/util.rs index 5857839a..af6370d0 100644 --- a/programs/util.rs +++ b/programs/util.rs @@ -218,9 +218,9 @@ pub unsafe fn UTIL_isFdRegularFile(fd: core::ffi::c_int) -> core::ffi::c_int { && UTIL_fstat( fd, b"\0" as *const u8 as *const core::ffi::c_char, - &mut statbuf, + &raw mut statbuf, ) != 0 - && UTIL_isRegularFileStat(&statbuf) != 0) as core::ffi::c_int; + && UTIL_isRegularFileStat(&raw const statbuf) != 0) as core::ffi::c_int; if g_traceFileStat != 0 { g_traceDepth -= 1; fprintf( @@ -251,8 +251,8 @@ pub unsafe fn UTIL_isRegularFile(infilename: *const core::ffi::c_char) -> core:: fprintf(stderr, b"\n\0" as *const u8 as *const core::ffi::c_char); g_traceDepth += 1; } - ret = (UTIL_stat(infilename, &mut statbuf) != 0 && UTIL_isRegularFileStat(&statbuf) != 0) - as core::ffi::c_int; + ret = (UTIL_stat(infilename, &raw mut statbuf) != 0 + && UTIL_isRegularFileStat(&raw const statbuf) != 0) as core::ffi::c_int; if g_traceFileStat != 0 { g_traceDepth -= 1; fprintf( @@ -301,7 +301,7 @@ pub unsafe fn UTIL_fchmod( g_traceDepth += 1; } if statbuf.is_null() { - if UTIL_fstat(fd, filename, &mut localStatBuf) == 0 { + if UTIL_fstat(fd, filename, &raw mut localStatBuf) == 0 { if g_traceFileStat != 0 { g_traceDepth -= 1; fprintf( @@ -314,7 +314,7 @@ pub unsafe fn UTIL_fchmod( } return 0; } - statbuf = &mut localStatBuf; + statbuf = &raw const localStatBuf; } if UTIL_isRegularFileStat(statbuf) == 0 { if g_traceFileStat != 0 { @@ -501,7 +501,9 @@ pub unsafe fn UTIL_setFDStat( fprintf(stderr, b"\n\0" as *const u8 as *const core::ffi::c_char); g_traceDepth += 1; } - if UTIL_fstat(fd, filename, &mut curStatBuf) == 0 || UTIL_isRegularFileStat(&curStatBuf) == 0 { + if UTIL_fstat(fd, filename, &raw mut curStatBuf) == 0 + || UTIL_isRegularFileStat(&raw const curStatBuf) == 0 + { if g_traceFileStat != 0 { g_traceDepth -= 1; fprintf( @@ -526,7 +528,7 @@ pub unsafe fn UTIL_setFDStat( res += UTIL_fchmod( fd, filename, - &curStatBuf, + &raw const curStatBuf, ((*statbuf).st_mode & 0o777) as mode_t, ); if fd >= 0 { @@ -594,8 +596,8 @@ pub unsafe fn UTIL_isDirectory(infilename: *const core::ffi::c_char) -> core::ff fprintf(stderr, b"\n\0" as *const u8 as *const core::ffi::c_char); g_traceDepth += 1; } - ret = (UTIL_stat(infilename, &mut statbuf) != 0 && UTIL_isDirectoryStat(&statbuf) != 0) - as core::ffi::c_int; + ret = (UTIL_stat(infilename, &raw mut statbuf) != 0 + && UTIL_isDirectoryStat(&raw const statbuf) != 0) as core::ffi::c_int; if g_traceFileStat != 0 { g_traceDepth -= 1; fprintf( @@ -723,9 +725,9 @@ pub unsafe fn UTIL_isSameFile( }, __glibc_reserved: [0; 3], }; - ret = (UTIL_stat(fName1, &mut file1Stat) != 0 - && UTIL_stat(fName2, &mut file2Stat) != 0 - && UTIL_isSameFileStat(fName1, fName2, &file1Stat, &file2Stat) != 0) + ret = (UTIL_stat(fName1, &raw mut file1Stat) != 0 + && UTIL_stat(fName2, &raw mut file2Stat) != 0 + && UTIL_isSameFileStat(fName1, fName2, &raw const file1Stat, &raw const file2Stat) != 0) as core::ffi::c_int; if g_traceFileStat != 0 { g_traceDepth -= 1; @@ -820,7 +822,7 @@ pub unsafe fn UTIL_isFIFO(infilename: *const core::ffi::c_char) -> core::ffi::c_ }, __glibc_reserved: [0; 3], }; - if UTIL_stat(infilename, &mut statbuf) != 0 && UTIL_isFIFOStat(&statbuf) != 0 { + if UTIL_stat(infilename, &raw mut statbuf) != 0 && UTIL_isFIFOStat(&raw const statbuf) != 0 { if g_traceFileStat != 0 { g_traceDepth -= 1; fprintf( @@ -965,7 +967,7 @@ pub unsafe fn UTIL_isLink(infilename: *const core::ffi::c_char) -> core::ffi::c_ }, __glibc_reserved: [0; 3], }; - let r = lstat(infilename, &mut statbuf); + let r = lstat(infilename, &raw mut statbuf); if r == 0 && statbuf.st_mode & __S_IFMT as __mode_t == 0o120000 as core::ffi::c_int as __mode_t { if g_traceFileStat != 0 { @@ -1084,7 +1086,7 @@ pub unsafe fn UTIL_getFileSize(infilename: *const core::ffi::c_char) -> u64 { fprintf(stderr, b"\n\0" as *const u8 as *const core::ffi::c_char); g_traceDepth += 1; } - if UTIL_stat(infilename, &mut statbuf) == 0 { + if UTIL_stat(infilename, &raw mut statbuf) == 0 { if g_traceFileStat != 0 { g_traceDepth -= 1; fprintf( @@ -1097,7 +1099,7 @@ pub unsafe fn UTIL_getFileSize(infilename: *const core::ffi::c_char) -> u64 { } return UTIL_FILESIZE_UNKNOWN as u64; } - let size = UTIL_getFileSizeStat(&statbuf); + let size = UTIL_getFileSizeStat(&raw const statbuf); if g_traceFileStat != 0 { g_traceDepth -= 1; fprintf( @@ -1359,11 +1361,11 @@ pub unsafe fn UTIL_createFileNamesTable_fromFileList( let mut buffer = core::ptr::null_mut(); let mut numLines = 0; let mut bufferSize = 0; - if UTIL_stat(fileList, &mut statbuf) == 0 { + if UTIL_stat(fileList, &raw mut statbuf) == 0 { return core::ptr::null_mut(); } - if UTIL_isRegularFileStat(&statbuf) == 0 - && UTIL_isFIFOStat(&statbuf) == 0 + if UTIL_isRegularFileStat(&raw const statbuf) == 0 + && UTIL_isFIFOStat(&raw const statbuf) == 0 && UTIL_isFileDescriptorPipe(fileList) == 0 { return core::ptr::null_mut(); @@ -1372,7 +1374,7 @@ pub unsafe fn UTIL_createFileNamesTable_fromFileList( if inFile.is_null() { return core::ptr::null_mut(); } - buffer = UTIL_readFileContent(inFile, &mut bufferSize); + buffer = UTIL_readFileContent(inFile, &raw mut bufferSize); fclose(inFile); if buffer.is_null() { return core::ptr::null_mut(); @@ -1760,7 +1762,7 @@ unsafe fn getDirMode(dirName: *const core::ffi::c_char) -> mode_t { }, __glibc_reserved: [0; 3], }; - if UTIL_stat(dirName, &mut st) == 0 { + if UTIL_stat(dirName, &raw mut st) == 0 { eprintln!( "zstd: failed to get DIR stats {}: {}", CStr::from_ptr(dirName).to_string_lossy(), @@ -1768,7 +1770,7 @@ unsafe fn getDirMode(dirName: *const core::ffi::c_char) -> mode_t { ); return DIR_DEFAULT_MODE as mode_t; } - if UTIL_isDirectoryStat(&st) == 0 { + if UTIL_isDirectoryStat(&raw const st) == 0 { fprintf( stderr, b"zstd: expected directory: %s\n\0" as *const u8 as *const core::ffi::c_char, @@ -2130,9 +2132,9 @@ pub unsafe fn UTIL_createExpandedFNT( } else { nbFiles = nbFiles.wrapping_add(UTIL_prepareFileList( *inputNames.add(ifnNb), - &mut buf, - &mut pos, - &mut bufend, + &raw mut buf, + &raw mut pos, + &raw mut bufend, followLinks, ) as core::ffi::c_uint); if buf.is_null() { diff --git a/programs/zstdcli.rs b/programs/zstdcli.rs index 0ac53c24..50dfca53 100644 --- a/programs/zstdcli.rs +++ b/programs/zstdcli.rs @@ -780,7 +780,7 @@ unsafe fn readU32FromCharChecked( } unsafe fn readU32FromChar(stringPtr: *mut *const core::ffi::c_char) -> core::ffi::c_uint { let mut result: core::ffi::c_uint = 0; - if readU32FromCharChecked(stringPtr, &mut result) != 0 { + if readU32FromCharChecked(stringPtr, &raw mut result) != 0 { errorOut(c"error: numeric value overflows 32-bit unsigned int".as_ptr()); } result @@ -792,7 +792,7 @@ unsafe fn readIntFromChar(stringPtr: *mut *const core::ffi::c_char) -> core::ffi *stringPtr = (*stringPtr).offset(1); sign = -(1); } - if readU32FromCharChecked(stringPtr, &mut result) != 0 { + if readU32FromCharChecked(stringPtr, &raw mut result) != 0 { errorOut(c"error: numeric value overflows 32-bit int".as_ptr()); } result as core::ffi::c_int * sign @@ -844,7 +844,7 @@ unsafe fn readSizeTFromCharChecked( } unsafe fn readSizeTFromChar(stringPtr: *mut *const core::ffi::c_char) -> size_t { let mut result: size_t = 0; - if readSizeTFromCharChecked(stringPtr, &mut result) != 0 { + if readSizeTFromCharChecked(stringPtr, &raw mut result) != 0 { errorOut(c"error: numeric value overflows size_t".as_ptr()); } result @@ -868,48 +868,48 @@ unsafe fn parseCoverParameters( ptr::write_bytes(params as *mut u8, 0, size_of::()); loop { if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"k=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - (*params).k = readU32FromChar(&mut stringPtr); + (*params).k = readU32FromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"d=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - (*params).d = readU32FromChar(&mut stringPtr); + (*params).d = readU32FromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"steps=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - (*params).steps = readU32FromChar(&mut stringPtr); + (*params).steps = readU32FromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"split=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - let splitPercentage = readU32FromChar(&mut stringPtr); + let splitPercentage = readU32FromChar(&raw mut stringPtr); (*params).splitPoint = splitPercentage as core::ffi::c_double / 100.0f64; if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"shrink\0" as *const u8 as *const core::ffi::c_char, ) != 0 { @@ -917,7 +917,7 @@ unsafe fn parseCoverParameters( (*params).shrinkDict = 1; if *stringPtr.offset(0) as core::ffi::c_int == '=' as i32 { stringPtr = stringPtr.offset(1); - (*params).shrinkDictMaxRegression = readU32FromChar(&mut stringPtr); + (*params).shrinkDictMaxRegression = readU32FromChar(&raw mut stringPtr); } if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; @@ -951,68 +951,68 @@ unsafe fn parseFastCoverParameters( ptr::write_bytes(params as *mut u8, 0, size_of::()); loop { if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"k=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - (*params).k = readU32FromChar(&mut stringPtr); + (*params).k = readU32FromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"d=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - (*params).d = readU32FromChar(&mut stringPtr); + (*params).d = readU32FromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"f=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - (*params).f = readU32FromChar(&mut stringPtr); + (*params).f = readU32FromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"steps=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - (*params).steps = readU32FromChar(&mut stringPtr); + (*params).steps = readU32FromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"accel=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - (*params).accel = readU32FromChar(&mut stringPtr); + (*params).accel = readU32FromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"split=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - let splitPercentage = readU32FromChar(&mut stringPtr); + let splitPercentage = readU32FromChar(&raw mut stringPtr); (*params).splitPoint = splitPercentage as core::ffi::c_double / 100.0f64; if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"shrink\0" as *const u8 as *const core::ffi::c_char, ) != 0 { @@ -1020,7 +1020,7 @@ unsafe fn parseFastCoverParameters( (*params).shrinkDict = 1; if *stringPtr.offset(0) as core::ffi::c_int == '=' as i32 { stringPtr = stringPtr.offset(1); - (*params).shrinkDictMaxRegression = readU32FromChar(&mut stringPtr); + (*params).shrinkDictMaxRegression = readU32FromChar(&raw mut stringPtr); } if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; @@ -1054,17 +1054,17 @@ unsafe fn parseLegacyParameters( selectivity: *mut core::ffi::c_uint, ) -> core::ffi::c_uint { if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"s=\0" as *const u8 as *const core::ffi::c_char, ) == 0 && longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"selectivity=\0" as *const u8 as *const core::ffi::c_char, ) == 0 { return 0; } - *selectivity = readU32FromChar(&mut stringPtr); + *selectivity = readU32FromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != 0 { return 0; } @@ -1107,21 +1107,21 @@ unsafe fn parseAdaptParameters( ) -> core::ffi::c_uint { loop { if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"min=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - *adaptMinPtr = readIntFromChar(&mut stringPtr); + *adaptMinPtr = readIntFromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"max=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - *adaptMaxPtr = readIntFromChar(&mut stringPtr); + *adaptMaxPtr = readIntFromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } @@ -1156,169 +1156,169 @@ unsafe fn parseCompressionParameters( ) -> core::ffi::c_uint { loop { if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"windowLog=\0" as *const u8 as *const core::ffi::c_char, ) != 0 || longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"wlog=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - (*params).windowLog = readU32FromChar(&mut stringPtr); + (*params).windowLog = readU32FromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"chainLog=\0" as *const u8 as *const core::ffi::c_char, ) != 0 || longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"clog=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - (*params).chainLog = readU32FromChar(&mut stringPtr); + (*params).chainLog = readU32FromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"hashLog=\0" as *const u8 as *const core::ffi::c_char, ) != 0 || longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"hlog=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - (*params).hashLog = readU32FromChar(&mut stringPtr); + (*params).hashLog = readU32FromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"searchLog=\0" as *const u8 as *const core::ffi::c_char, ) != 0 || longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"slog=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - (*params).searchLog = readU32FromChar(&mut stringPtr); + (*params).searchLog = readU32FromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"minMatch=\0" as *const u8 as *const core::ffi::c_char, ) != 0 || longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"mml=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - (*params).minMatch = readU32FromChar(&mut stringPtr); + (*params).minMatch = readU32FromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"targetLength=\0" as *const u8 as *const core::ffi::c_char, ) != 0 || longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"tlen=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - (*params).targetLength = readU32FromChar(&mut stringPtr); + (*params).targetLength = readU32FromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"strategy=\0" as *const u8 as *const core::ffi::c_char, ) != 0 || longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"strat=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - (*params).strategy = readU32FromChar(&mut stringPtr) as ZSTD_strategy; + (*params).strategy = readU32FromChar(&raw mut stringPtr) as ZSTD_strategy; if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"overlapLog=\0" as *const u8 as *const core::ffi::c_char, ) != 0 || longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"ovlog=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - g_overlapLog = readU32FromChar(&mut stringPtr); + g_overlapLog = readU32FromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"ldmHashLog=\0" as *const u8 as *const core::ffi::c_char, ) != 0 || longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"lhlog=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - g_ldmHashLog = readU32FromChar(&mut stringPtr); + g_ldmHashLog = readU32FromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"ldmMinMatch=\0" as *const u8 as *const core::ffi::c_char, ) != 0 || longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"lmml=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - g_ldmMinMatch = readU32FromChar(&mut stringPtr); + g_ldmMinMatch = readU32FromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"ldmBucketSizeLog=\0" as *const u8 as *const core::ffi::c_char, ) != 0 || longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"lblog=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - g_ldmBucketSizeLog = readU32FromChar(&mut stringPtr); + g_ldmBucketSizeLog = readU32FromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } stringPtr = stringPtr.offset(1); } else if longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"ldmHashRateLog=\0" as *const u8 as *const core::ffi::c_char, ) != 0 || longCommandWArg( - &mut stringPtr, + &raw mut stringPtr, b"lhrlog=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - g_ldmHashRateLog = readU32FromChar(&mut stringPtr); + g_ldmHashRateLog = readU32FromChar(&raw mut stringPtr); if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { break; } @@ -1624,7 +1624,7 @@ unsafe fn init_cLevel() -> core::ffi::c_int { } if *ptr as core::ffi::c_int >= '0' as i32 && *ptr as core::ffi::c_int <= '9' as i32 { let mut absLevel: core::ffi::c_uint = 0; - if readU32FromCharChecked(&mut ptr, &mut absLevel) != 0 { + if readU32FromCharChecked(&raw mut ptr, &raw mut absLevel) != 0 { if g_displayLevel >= 2 { fprintf( stderr, @@ -1657,7 +1657,7 @@ unsafe fn init_nbWorkers() -> core::ffi::c_uint { let mut ptr = env; if *ptr as core::ffi::c_int >= '0' as i32 && *ptr as core::ffi::c_int <= '9' as i32 { let mut nbThreads: core::ffi::c_uint = 0; - if readU32FromCharChecked(&mut ptr, &mut nbThreads) != 0 { + if readU32FromCharChecked(&raw mut ptr, &raw mut nbThreads) != 0 { if g_displayLevel >= 2 { fprintf( stderr, @@ -1868,7 +1868,7 @@ unsafe fn main_0( cType = FIO_lz4Compression; } ptr::write_bytes( - &mut compressionParams as *mut ZSTD_compressionParameters as *mut u8, + &raw mut compressionParams as *mut u8, 0, size_of::(), ); @@ -2152,12 +2152,14 @@ unsafe fn main_0( { useRowMatchFinder = ZSTD_ParamSwitch_e::ZSTD_ps_enable; } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--adapt=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { adapt = 1; - if parseAdaptParameters(argument, &mut adaptMin, &mut adaptMax) == 0 { + if parseAdaptParameters(argument, &raw mut adaptMin, &raw mut adaptMax) + == 0 + { badUsage(programName, originalArgument); operationResult = 1; break 'end; @@ -2311,10 +2313,10 @@ unsafe fn main_0( } else { ultra = 1; ldmFlag = 1; - setMaxCompression(&mut compressionParams); + setMaxCompression(&raw mut compressionParams); } } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--train-cover\0" as *const u8 as *const core::ffi::c_char, ) != 0 { @@ -2325,7 +2327,7 @@ unsafe fn main_0( dict = cover; if *argument as core::ffi::c_int == 0 { ptr::write_bytes( - &mut coverParams as *mut ZDICT_cover_params_t as *mut u8, + &raw mut coverParams as *mut u8, 0, size_of::(), ); @@ -2336,7 +2338,8 @@ unsafe fn main_0( badUsage(programName, originalArgument); operationResult = 1; break 'end; - } else if parseCoverParameters(argument, &mut coverParams) == 0 + } else if parseCoverParameters(argument, &raw mut coverParams) + == 0 { badUsage(programName, originalArgument); operationResult = 1; @@ -2344,7 +2347,7 @@ unsafe fn main_0( } } } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--train-fastcover\0" as *const u8 as *const core::ffi::c_char, ) != 0 { @@ -2355,8 +2358,7 @@ unsafe fn main_0( dict = fastCover; if *argument as core::ffi::c_int == 0 { ptr::write_bytes( - &mut fastCoverParams as *mut ZDICT_fastCover_params_t - as *mut u8, + &raw mut fastCoverParams as *mut u8, 0, size_of::(), ); @@ -2369,7 +2371,7 @@ unsafe fn main_0( break 'end; } else if parseFastCoverParameters( argument, - &mut fastCoverParams, + &raw mut fastCoverParams, ) == 0 { badUsage(programName, originalArgument); @@ -2378,7 +2380,7 @@ unsafe fn main_0( } } } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--train-legacy\0" as *const u8 as *const core::ffi::c_char, ) != 0 { @@ -2394,7 +2396,8 @@ unsafe fn main_0( badUsage(programName, originalArgument); operationResult = 1; break 'end; - } else if parseLegacyParameters(argument, &mut dictSelect) == 0 + } else if parseLegacyParameters(argument, &raw mut dictSelect) + == 0 { badUsage(programName, originalArgument); operationResult = 1; @@ -2402,66 +2405,67 @@ unsafe fn main_0( } } } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--threads\0" as *const u8 as *const core::ffi::c_char, ) != 0 { NEXT_UINT32!(nbWorkers); setThreads_non1 = (nbWorkers != 1) as core::ffi::c_int; } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--memlimit\0" as *const u8 as *const core::ffi::c_char, ) != 0 { NEXT_UINT32!(memLimit); } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--memory\0" as *const u8 as *const core::ffi::c_char, ) != 0 { NEXT_UINT32!(memLimit); } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--memlimit-decompress\0" as *const u8 as *const core::ffi::c_char, ) != 0 { NEXT_UINT32!(memLimit); } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--block-size\0" as *const u8 as *const core::ffi::c_char, ) != 0 { NEXT_TSIZE!(chunkSize); } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--split\0" as *const u8 as *const core::ffi::c_char, ) != 0 { NEXT_TSIZE!(chunkSize); } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--jobsize\0" as *const u8 as *const core::ffi::c_char, ) != 0 { NEXT_TSIZE!(chunkSize); } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--maxdict\0" as *const u8 as *const core::ffi::c_char, ) != 0 { NEXT_UINT32!(maxDictSize); } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--dictID\0" as *const u8 as *const core::ffi::c_char, ) != 0 { NEXT_UINT32!(dictID); } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--zstd=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - if parseCompressionParameters(argument, &mut compressionParams) == 0 + if parseCompressionParameters(argument, &raw mut compressionParams) + == 0 { badUsage(programName, originalArgument); operationResult = 1; @@ -2470,26 +2474,26 @@ unsafe fn main_0( cType = FIO_zstdCompression; } } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--stream-size\0" as *const u8 as *const core::ffi::c_char, ) != 0 { NEXT_TSIZE!(streamSrcSize); } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--target-compressed-block-size\0" as *const u8 as *const core::ffi::c_char, ) != 0 { NEXT_TSIZE!(targetCBlockSize); } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--size-hint\0" as *const u8 as *const core::ffi::c_char, ) != 0 { NEXT_TSIZE!(srcSizeHint); } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--output-dir-flat\0" as *const u8 as *const core::ffi::c_char, ) != 0 { @@ -2506,7 +2510,7 @@ unsafe fn main_0( break 'end; } } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--auto-threads\0" as *const u8 as *const core::ffi::c_char, ) != 0 { @@ -2520,7 +2524,7 @@ unsafe fn main_0( defaultLogicalCores = 1; } } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--output-dir-mirror\0" as *const u8 as *const core::ffi::c_char, ) != 0 { @@ -2537,7 +2541,7 @@ unsafe fn main_0( break 'end; } } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--trace\0" as *const u8 as *const core::ffi::c_char, ) != 0 { @@ -2545,14 +2549,14 @@ unsafe fn main_0( NEXT_FIELD!(traceFile); TRACE_enable(traceFile); } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--patch-from\0" as *const u8 as *const core::ffi::c_char, ) != 0 { NEXT_FIELD!(patchFromDictFileName); ultra = 1; } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--patch-apply\0" as *const u8 as *const core::ffi::c_char, ) != 0 { @@ -2565,7 +2569,7 @@ unsafe fn main_0( ZSTD_WINDOWLOG_MAX_64 }); } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--long\0" as *const u8 as *const core::ffi::c_char, ) != 0 { @@ -2574,7 +2578,7 @@ unsafe fn main_0( ultra = 1; if *argument as core::ffi::c_int == '=' as i32 { argument = argument.offset(1); - ldmWindowLog = readU32FromChar(&mut argument); + ldmWindowLog = readU32FromChar(&raw mut argument); } else if *argument as core::ffi::c_int != 0 { badUsage(programName, originalArgument); operationResult = 1; @@ -2586,7 +2590,7 @@ unsafe fn main_0( compressionParams.windowLog = ldmWindowLog; } } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--fast\0" as *const u8 as *const core::ffi::c_char, ) != 0 { @@ -2594,7 +2598,7 @@ unsafe fn main_0( let maxFast = -ZSTD_minCLevel() as u32; let mut fastLevel: u32 = 0; argument = argument.offset(1); - fastLevel = readU32FromChar(&mut argument); + fastLevel = readU32FromChar(&raw mut argument); if fastLevel > maxFast { fastLevel = maxFast; } @@ -2614,7 +2618,7 @@ unsafe fn main_0( cLevel = -(1); } } else if longCommandWArg( - &mut argument, + &raw mut argument, b"--filelist\0" as *const u8 as *const core::ffi::c_char, ) != 0 { @@ -2633,7 +2637,7 @@ unsafe fn main_0( if *argument as core::ffi::c_int >= '0' as i32 && *argument as core::ffi::c_int <= '9' as i32 { - cLevel = readU32FromChar(&mut argument) as core::ffi::c_int; + cLevel = readU32FromChar(&raw mut argument) as core::ffi::c_int; dictCLevel = cLevel; } else { match *argument.offset(0) as core::ffi::c_int { @@ -2713,7 +2717,7 @@ unsafe fn main_0( } 77 => { argument = argument.offset(1); - memLimit = readU32FromChar(&mut argument); + memLimit = readU32FromChar(&raw mut argument); } 108 => { operation = zom_list; @@ -2730,15 +2734,15 @@ unsafe fn main_0( 101 => { argument = argument.offset(1); cLevelLast = - readU32FromChar(&mut argument) as core::ffi::c_int; + readU32FromChar(&raw mut argument) as core::ffi::c_int; } 105 => { argument = argument.offset(1); - bench_nbSeconds = readU32FromChar(&mut argument); + bench_nbSeconds = readU32FromChar(&raw mut argument); } 66 => { argument = argument.offset(1); - chunkSize = readU32FromChar(&mut argument) as size_t; + chunkSize = readU32FromChar(&raw mut argument) as size_t; } 83 => { argument = argument.offset(1); @@ -2746,12 +2750,12 @@ unsafe fn main_0( } 84 => { argument = argument.offset(1); - nbWorkers = readU32FromChar(&mut argument); + nbWorkers = readU32FromChar(&raw mut argument); setThreads_non1 = (nbWorkers != 1) as core::ffi::c_int; } 115 => { argument = argument.offset(1); - dictSelect = readU32FromChar(&mut argument); + dictSelect = readU32FromChar(&raw mut argument); } 112 => { argument = argument.offset(1); @@ -2759,14 +2763,15 @@ unsafe fn main_0( && *argument as core::ffi::c_int <= '9' as i32 { benchParams.additionalParam = - readU32FromChar(&mut argument) as core::ffi::c_int; + readU32FromChar(&raw mut argument) + as core::ffi::c_int; } else { main_pause = 1; } } 80 => { argument = argument.offset(1); - compressibility = readU32FromChar(&mut argument) + compressibility = readU32FromChar(&raw mut argument) as core::ffi::c_double / 100.0; } @@ -2903,7 +2908,7 @@ unsafe fn main_0( } nbInputFileNames = (*filenames).tableSize; if recursive != 0 { - UTIL_expandFNT(&mut filenames, followLinks); + UTIL_expandFNT(&raw mut filenames, followLinks); } if operation as core::ffi::c_uint == zom_list as core::ffi::c_int as core::ffi::c_uint { let ret = FIO_listMultipleFiles( @@ -3000,14 +3005,14 @@ unsafe fn main_0( i = 0; while (i as size_t) < (*filenames).tableSize { operationResult = BMK_benchFilesAdvanced( - &*((*filenames).fileNames).offset(i as isize), + &raw const *((*filenames).fileNames).offset(i as isize), 1, dictFileName, cLevel, cLevelLast, - &compressionParams, + &raw const compressionParams, g_displayLevel, - &benchParams, + &raw const benchParams, ); i = i.wrapping_add(1); } @@ -3018,9 +3023,9 @@ unsafe fn main_0( dictFileName, cLevel, cLevelLast, - &compressionParams, + &raw const compressionParams, g_displayLevel, - &benchParams, + &raw const benchParams, ); } } else { @@ -3028,9 +3033,9 @@ unsafe fn main_0( compressibility, cLevel, cLevelLast, - &compressionParams, + &raw const compressionParams, g_displayLevel, - &benchParams, + &raw const benchParams, ); } } @@ -3053,7 +3058,7 @@ unsafe fn main_0( (*filenames).tableSize as core::ffi::c_int, chunkSize, core::ptr::null_mut(), - &mut coverParams, + &raw mut coverParams, core::ptr::null_mut(), optimize, memLimit, @@ -3073,7 +3078,7 @@ unsafe fn main_0( chunkSize, core::ptr::null_mut(), core::ptr::null_mut(), - &mut fastCoverParams, + &raw mut fastCoverParams, optimize_0, memLimit, ); @@ -3087,7 +3092,7 @@ unsafe fn main_0( (*filenames).fileNames, (*filenames).tableSize as core::ffi::c_int, chunkSize, - &mut dictParams, + &raw mut dictParams, core::ptr::null_mut(), core::ptr::null_mut(), 0, @@ -3303,7 +3308,7 @@ unsafe fn main_0( *((*filenames).fileNames).add(fileNb), dictFileName, cLevel, - &compressionParams, + &raw const compressionParams, ); } fileNb = fileNb.wrapping_add(1); diff --git a/programs/zstdcli_trace.rs b/programs/zstdcli_trace.rs index 621832e1..02e8af34 100644 --- a/programs/zstdcli_trace.rs +++ b/programs/zstdcli_trace.rs @@ -51,12 +51,12 @@ unsafe fn TRACE_log(method: &str, duration: PTime, trace: &ZSTD_Trace) { ZSTD_CCtxParams_getParameter( trace.params, ZSTD_cParameter::ZSTD_c_compressionLevel, - &mut level, + &raw mut level, ); ZSTD_CCtxParams_getParameter( trace.params, ZSTD_cParameter::ZSTD_c_nbWorkers, - &mut workers, + &raw mut workers, ); } writeln!( From 5245fdb8f12f92df715b08933ebb4b0249049fa3 Mon Sep 17 00:00:00 2001 From: Mattias Wallin Date: Fri, 5 Jun 2026 15:56:03 +0200 Subject: [PATCH 02/16] Fix clippy::absurd_extreme_comparisons --- programs/datagen.rs | 5 +---- programs/fileio.rs | 2 +- programs/main.rs | 1 + programs/util.rs | 2 +- 4 files changed, 4 insertions(+), 6 deletions(-) diff --git a/programs/datagen.rs b/programs/datagen.rs index 768c2aad..29830dd5 100644 --- a/programs/datagen.rs +++ b/programs/datagen.rs @@ -19,7 +19,7 @@ unsafe fn RDG_rand(src: *mut u32) -> u32 { *src = rand32; rand32 >> 5 } -unsafe fn RDG_fillLiteralDistrib(ldt: *mut u8, mut ld: fixedPoint_24_8) { +unsafe fn RDG_fillLiteralDistrib(ldt: *mut u8, ld: fixedPoint_24_8) { let firstChar = (if ld as core::ffi::c_double <= 0.0f64 { 0 } else { @@ -36,9 +36,6 @@ unsafe fn RDG_fillLiteralDistrib(ldt: *mut u8, mut ld: fixedPoint_24_8) { '0' as i32 }) as u8; let mut u: u32 = 0; - if ld <= 0 { - ld = 0; - } u = 0; while u < LTSIZE as u32 { let weight = (((LTSIZE as u32).wrapping_sub(u) * ld) >> 8).wrapping_add(1); diff --git a/programs/fileio.rs b/programs/fileio.rs index 1caf07d7..d13a1e89 100644 --- a/programs/fileio.rs +++ b/programs/fileio.rs @@ -4167,7 +4167,7 @@ unsafe fn FIO_compressZstdFrame( ); } if zfp.currentJobID > ((*prefs).nbWorkers + 1) as core::ffi::c_uint { - if inputBlocked <= 0 { + if inputBlocked == 0 { if g_display_prefs.displayLevel >= 6 { fprintf( stderr, diff --git a/programs/main.rs b/programs/main.rs index e0d4d086..1676a9fc 100644 --- a/programs/main.rs +++ b/programs/main.rs @@ -6,6 +6,7 @@ // FIXME I guess #![allow(clippy::all)] #![warn(clippy::borrow_as_ptr)] +#![warn(clippy::absurd_extreme_comparisons)] extern crate libc; pub mod benchfn; diff --git a/programs/util.rs b/programs/util.rs index af6370d0..e3ab201e 100644 --- a/programs/util.rs +++ b/programs/util.rs @@ -1251,7 +1251,7 @@ unsafe fn UTIL_readFileContent( bufSize.wrapping_sub(totalRead).wrapping_sub(1), inFile, ); - if bytesRead <= 0 { + if bytesRead == 0 { break; } totalRead = totalRead.wrapping_add(bytesRead); From cb40b2085693a432c8021fb027fb25f3402d650c Mon Sep 17 00:00:00 2001 From: Mattias Wallin Date: Fri, 5 Jun 2026 16:03:55 +0200 Subject: [PATCH 03/16] Fix clippy::eq_op --- programs/fileio.rs | 10 ++-------- programs/main.rs | 1 + 2 files changed, 3 insertions(+), 8 deletions(-) diff --git a/programs/fileio.rs b/programs/fileio.rs index d13a1e89..6b9d822b 100644 --- a/programs/fileio.rs +++ b/programs/fileio.rs @@ -27,7 +27,7 @@ use libzstd_rs_sys::lib::decompress::zstd_decompress::{ }; use libzstd_rs_sys::lib::decompress::{ZSTD_DCtx, ZSTD_FrameHeader, ZSTD_frame}; use libzstd_rs_sys::lib::zstd::{ - ZSTD_ParamSwitch_e, ZSTD_ResetDirective, ZSTD_btlazy2, ZSTD_btopt, ZSTD_cParameter, + Format, ZSTD_ParamSwitch_e, ZSTD_ResetDirective, ZSTD_btlazy2, ZSTD_btopt, ZSTD_cParameter, ZSTD_compressionParameters, ZSTD_dParameter, ZSTD_error_frameParameter_windowTooLarge, ZSTD_frameProgression, ZSTD_inBuffer, ZSTD_inBuffer_s, ZSTD_outBuffer, ZSTD_outBuffer_s, ZSTD_strategy, ZSTD_BLOCKSIZE_MAX, ZSTD_CONTENTSIZE_ERROR, ZSTD_CONTENTSIZE_UNKNOWN, @@ -6847,13 +6847,7 @@ unsafe fn FIO_analyzeFrames(info: *mut fileInfo_t, srcFile: *mut FILE) -> InfoEr size_of::<[u8; 18]>(), srcFile, ); - if numBytesRead - < (if ZSTD_f_zstd1 as core::ffi::c_int == ZSTD_f_zstd1 as core::ffi::c_int { - 6 - } else { - 2 - }) as size_t - { + if numBytesRead < Format::ZSTD_f_zstd1.frame_header_size_min() { if feof(srcFile) != 0 && numBytesRead == 0 && (*info).compressedSize > 0 diff --git a/programs/main.rs b/programs/main.rs index 1676a9fc..f8e46ca0 100644 --- a/programs/main.rs +++ b/programs/main.rs @@ -7,6 +7,7 @@ #![allow(clippy::all)] #![warn(clippy::borrow_as_ptr)] #![warn(clippy::absurd_extreme_comparisons)] +#![warn(clippy::eq_op)] extern crate libc; pub mod benchfn; From f135a0d5b3d2bc0e4b35a72e6327acaef84e95ea Mon Sep 17 00:00:00 2001 From: Mattias Wallin Date: Sat, 6 Jun 2026 08:25:44 +0200 Subject: [PATCH 04/16] Fix clippy::unnecessary_cast --- programs/datagen.rs | 4 ++-- programs/main.rs | 1 + 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/programs/datagen.rs b/programs/datagen.rs index 29830dd5..30faa409 100644 --- a/programs/datagen.rs +++ b/programs/datagen.rs @@ -151,7 +151,7 @@ pub unsafe fn RDG_genBuffer( ) { let mut seed32 = seed; let mut ldt: [u8; 8192] = [0; 8192]; - ptr::write_bytes(ldt.as_mut_ptr() as *mut u8, b'0', size_of::<[u8; 8192]>()); + ptr::write_bytes(ldt.as_mut_ptr(), b'0', size_of::<[u8; 8192]>()); if litProba <= 0.0f64 { litProba = matchProba / 4.5f64; } @@ -187,7 +187,7 @@ pub unsafe fn RDG_genStdout( if litProba <= 0.0f64 { litProba = matchProba / 4.5f64; } - ptr::write_bytes(ldt.as_mut_ptr() as *mut u8, b'0', size_of::<[u8; 8192]>()); + ptr::write_bytes(ldt.as_mut_ptr(), b'0', size_of::<[u8; 8192]>()); RDG_fillLiteralDistrib( ldt.as_mut_ptr(), (litProba * 256.0 + 0.001f64) as fixedPoint_24_8, diff --git a/programs/main.rs b/programs/main.rs index f8e46ca0..b3718f0c 100644 --- a/programs/main.rs +++ b/programs/main.rs @@ -8,6 +8,7 @@ #![warn(clippy::borrow_as_ptr)] #![warn(clippy::absurd_extreme_comparisons)] #![warn(clippy::eq_op)] +#![warn(clippy::unnecessary_cast)] extern crate libc; pub mod benchfn; From 04ad6584afcebfd4e3ea8fdd87ccda174b217a16 Mon Sep 17 00:00:00 2001 From: Mattias Wallin Date: Sat, 6 Jun 2026 08:35:49 +0200 Subject: [PATCH 05/16] Fix clippy::field_reassign_with_default --- programs/main.rs | 1 + programs/zstdcli.rs | 41 ++++++++++++++++++++++------------------- 2 files changed, 23 insertions(+), 19 deletions(-) diff --git a/programs/main.rs b/programs/main.rs index b3718f0c..d8284933 100644 --- a/programs/main.rs +++ b/programs/main.rs @@ -9,6 +9,7 @@ #![warn(clippy::absurd_extreme_comparisons)] #![warn(clippy::eq_op)] #![warn(clippy::unnecessary_cast)] +#![warn(clippy::field_reassign_with_default)] extern crate libc; pub mod benchfn; diff --git a/programs/zstdcli.rs b/programs/zstdcli.rs index 50dfca53..8d6e9813 100644 --- a/programs/zstdcli.rs +++ b/programs/zstdcli.rs @@ -1079,25 +1079,27 @@ unsafe fn parseLegacyParameters( } fn defaultCoverParams() -> ZDICT_cover_params_t { - let mut params = ZDICT_cover_params_t::default(); - params.d = 8; - params.steps = 4; - params.splitPoint = 1.0f64; - params.shrinkDict = 0; - params.shrinkDictMaxRegression = kDefaultRegression; - params + ZDICT_cover_params_t { + d: 8, + steps: 4, + splitPoint: 1.0f64, + shrinkDict: 0, + shrinkDictMaxRegression: kDefaultRegression, + ..Default::default() + } } fn defaultFastCoverParams() -> ZDICT_fastCover_params_t { - let mut params = ZDICT_fastCover_params_t::default(); - params.d = 8; - params.f = 20; - params.steps = 4; - params.splitPoint = 0.75f64; - params.accel = DEFAULT_ACCEL as core::ffi::c_uint; - params.shrinkDict = 0; - params.shrinkDictMaxRegression = kDefaultRegression; - params + ZDICT_fastCover_params_t { + d: 8, + f: 20, + steps: 4, + splitPoint: 0.75f64, + accel: DEFAULT_ACCEL as core::ffi::c_uint, + shrinkDict: 0, + shrinkDictMaxRegression: kDefaultRegression, + ..Default::default() + } } unsafe fn parseAdaptParameters( @@ -3083,9 +3085,10 @@ unsafe fn main_0( memLimit, ); } else { - let mut dictParams = ZDICT_legacy_params_t::default(); - dictParams.selectivityLevel = dictSelect; - dictParams.zParams = zParams; + let mut dictParams = ZDICT_legacy_params_t { + selectivityLevel: dictSelect, + zParams, + }; operationResult = DiB_trainFromFiles( outFileName, maxDictSize as size_t, From 8782ceb6f1ff6f5a45fc9804dcbe2dfa791db176 Mon Sep 17 00:00:00 2001 From: Mattias Wallin Date: Sat, 6 Jun 2026 08:41:57 +0200 Subject: [PATCH 06/16] Fix clippy::manual_clamp --- programs/fileio.rs | 7 +------ programs/main.rs | 1 + 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/programs/fileio.rs b/programs/fileio.rs index 6b9d822b..309b09f5 100644 --- a/programs/fileio.rs +++ b/programs/fileio.rs @@ -3556,12 +3556,7 @@ unsafe fn FIO_compressLzmaFrame( let mut action = LZMA_RUN; let mut ret = LZMA_OK; let mut writeJob = core::ptr::null_mut(); - if compressionLevel < 0 { - compressionLevel = 0; - } - if compressionLevel > 9 { - compressionLevel = 9; - } + compressionLevel = compressionLevel.clamp(0, 9); if plain_lzma != 0 { let mut opt_lzma = lzma_options_lzma { dict_size: 0, diff --git a/programs/main.rs b/programs/main.rs index d8284933..c366c15b 100644 --- a/programs/main.rs +++ b/programs/main.rs @@ -10,6 +10,7 @@ #![warn(clippy::eq_op)] #![warn(clippy::unnecessary_cast)] #![warn(clippy::field_reassign_with_default)] +#![warn(clippy::manual_clamp)] extern crate libc; pub mod benchfn; From 07cb940a9ef25fcb811948f3c3180c72dbc37947 Mon Sep 17 00:00:00 2001 From: Mattias Wallin Date: Sat, 6 Jun 2026 09:03:35 +0200 Subject: [PATCH 07/16] Fix clippy::manual_checked_ops --- programs/dibio.rs | 10 +++++++--- programs/main.rs | 1 + 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/programs/dibio.rs b/programs/dibio.rs index 85c3daf5..71b943ae 100644 --- a/programs/dibio.rs +++ b/programs/dibio.rs @@ -1,6 +1,8 @@ use core::ptr; use std::ffi::CStr; use std::io; +use std::num::NonZeroUsize; +use std::ops::Div as _; use libc::{exit, fclose, fflush, fopen, fprintf, fread, free, fwrite, malloc, size_t, FILE}; use libzstd_rs_sys::lib::zdict::experimental::{ @@ -333,9 +335,11 @@ unsafe fn DiB_fileStats( *fileNamesTable.offset(n as isize), ); } - } else if chunkSize > 0 { - fs.nbSamples += ((fileSize as size_t).wrapping_add(chunkSize).wrapping_sub(1) - / chunkSize) as core::ffi::c_int; + } else if let Some(chunkSize) = NonZeroUsize::new(chunkSize) { + fs.nbSamples += (fileSize as size_t) + .wrapping_add(chunkSize.get()) + .wrapping_sub(1) + .div(chunkSize) as core::ffi::c_int; fs.totalSizeToLoad += fileSize; } else { if fileSize > SAMPLESIZE_MAX as i64 { diff --git a/programs/main.rs b/programs/main.rs index c366c15b..a10912e7 100644 --- a/programs/main.rs +++ b/programs/main.rs @@ -11,6 +11,7 @@ #![warn(clippy::unnecessary_cast)] #![warn(clippy::field_reassign_with_default)] #![warn(clippy::manual_clamp)] +#![warn(clippy::manual_checked_ops)] extern crate libc; pub mod benchfn; From 502b66a03275e8dff911a841f6f295ce33800c32 Mon Sep 17 00:00:00 2001 From: Mattias Wallin Date: Sat, 6 Jun 2026 09:07:19 +0200 Subject: [PATCH 08/16] Fix clippy::double_parens --- programs/dibio.rs | 6 +----- programs/main.rs | 1 + 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/programs/dibio.rs b/programs/dibio.rs index 71b943ae..3693b826 100644 --- a/programs/dibio.rs +++ b/programs/dibio.rs @@ -446,11 +446,7 @@ pub unsafe fn DiB_trainFromFiles( stderr, b"! Warning : setting manual memory limit for dictionary training data at %u MB \n\0" as *const u8 as *const core::ffi::c_char, - memLimit - .wrapping_div( - (((1) << 20)) - as core::ffi::c_uint, - ), + memLimit.wrapping_div(1 << 20), ); } loadedSize = if loadedSize < memLimit as size_t { diff --git a/programs/main.rs b/programs/main.rs index a10912e7..15317503 100644 --- a/programs/main.rs +++ b/programs/main.rs @@ -12,6 +12,7 @@ #![warn(clippy::field_reassign_with_default)] #![warn(clippy::manual_clamp)] #![warn(clippy::manual_checked_ops)] +#![warn(clippy::double_parens)] extern crate libc; pub mod benchfn; From ebf1e80ed7438f6bcfbb7122c2f60f1a123aa225 Mon Sep 17 00:00:00 2001 From: Mattias Wallin Date: Sat, 6 Jun 2026 09:09:48 +0200 Subject: [PATCH 09/16] Fix clippy::redundant_field_names --- programs/main.rs | 1 + programs/zstdcli.rs | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/programs/main.rs b/programs/main.rs index 15317503..3ae6768f 100644 --- a/programs/main.rs +++ b/programs/main.rs @@ -13,6 +13,7 @@ #![warn(clippy::manual_clamp)] #![warn(clippy::manual_checked_ops)] #![warn(clippy::double_parens)] +#![warn(clippy::redundant_field_names)] extern crate libc; pub mod benchfn; diff --git a/programs/zstdcli.rs b/programs/zstdcli.rs index 8d6e9813..06f99bf0 100644 --- a/programs/zstdcli.rs +++ b/programs/zstdcli.rs @@ -3047,7 +3047,7 @@ unsafe fn main_0( let zParams = ZDICT_params_t { compressionLevel: dictCLevel, notificationLevel: g_displayLevel as core::ffi::c_uint, - dictID: dictID, + dictID, }; if dict as core::ffi::c_uint == cover as core::ffi::c_int as core::ffi::c_uint { let optimize = (coverParams.k == 0 || coverParams.d == 0) as core::ffi::c_int; From f12e554bb693bf0e196f551c64fa9d3a345aa411 Mon Sep 17 00:00:00 2001 From: Mattias Wallin Date: Sat, 6 Jun 2026 09:20:20 +0200 Subject: [PATCH 10/16] Fix clippy::if_same_then_else --- programs/main.rs | 1 + programs/util.rs | 9 +++-- programs/zstdcli.rs | 80 +++++++++++++++++---------------------------- 3 files changed, 35 insertions(+), 55 deletions(-) diff --git a/programs/main.rs b/programs/main.rs index 3ae6768f..41da7127 100644 --- a/programs/main.rs +++ b/programs/main.rs @@ -14,6 +14,7 @@ #![warn(clippy::manual_checked_ops)] #![warn(clippy::double_parens)] #![warn(clippy::redundant_field_names)] +#![warn(clippy::if_same_then_else)] extern crate libc; pub mod benchfn; diff --git a/programs/util.rs b/programs/util.rs index e3ab201e..3d89a8fd 100644 --- a/programs/util.rs +++ b/programs/util.rs @@ -1014,11 +1014,10 @@ pub unsafe fn UTIL_isConsole(file: *mut FILE) -> core::ffi::c_int { fprintf(stderr, b"\n\0" as *const u8 as *const core::ffi::c_char); g_traceDepth += 1; } - if file == stdin && g_fakeStdinIsConsole != 0 { - ret = 1; - } else if file == stderr && g_fakeStderrIsConsole != 0 { - ret = 1; - } else if file == stdout && g_fakeStdoutIsConsole != 0 { + if (file == stdin && g_fakeStdinIsConsole != 0) + || (file == stderr && g_fakeStderrIsConsole != 0) + || (file == stdout && g_fakeStdoutIsConsole != 0) + { ret = 1; } else { ret = isatty(fileno(file)); diff --git a/programs/zstdcli.rs b/programs/zstdcli.rs index 06f99bf0..300d109d 100644 --- a/programs/zstdcli.rs +++ b/programs/zstdcli.rs @@ -1971,12 +1971,10 @@ unsafe fn main_0( argument, b"--decompress\0" as *const u8 as *const core::ffi::c_char, ) == 0 - { - operation = zom_decompress; - } else if strcmp( - argument, - b"--uncompress\0" as *const u8 as *const core::ffi::c_char, - ) == 0 + || strcmp( + argument, + b"--uncompress\0" as *const u8 as *const core::ffi::c_char, + ) == 0 { operation = zom_decompress; } else if strcmp( @@ -2336,12 +2334,8 @@ unsafe fn main_0( } else { let fresh0 = argument; argument = argument.offset(1); - if *fresh0 as core::ffi::c_int != '=' as i32 { - badUsage(programName, originalArgument); - operationResult = 1; - break 'end; - } else if parseCoverParameters(argument, &raw mut coverParams) - == 0 + if *fresh0 as core::ffi::c_int != '=' as i32 + || parseCoverParameters(argument, &raw mut coverParams) == 0 { badUsage(programName, originalArgument); operationResult = 1; @@ -2367,14 +2361,11 @@ unsafe fn main_0( } else { let fresh1 = argument; argument = argument.offset(1); - if *fresh1 as core::ffi::c_int != '=' as i32 { - badUsage(programName, originalArgument); - operationResult = 1; - break 'end; - } else if parseFastCoverParameters( - argument, - &raw mut fastCoverParams, - ) == 0 + if *fresh1 as core::ffi::c_int != '=' as i32 + || parseFastCoverParameters( + argument, + &raw mut fastCoverParams, + ) == 0 { badUsage(programName, originalArgument); operationResult = 1; @@ -2394,12 +2385,8 @@ unsafe fn main_0( if *argument as core::ffi::c_int != 0 { let fresh2 = argument; argument = argument.offset(1); - if *fresh2 as core::ffi::c_int != '=' as i32 { - badUsage(programName, originalArgument); - operationResult = 1; - break 'end; - } else if parseLegacyParameters(argument, &raw mut dictSelect) - == 0 + if *fresh2 as core::ffi::c_int != '=' as i32 + || parseLegacyParameters(argument, &raw mut dictSelect) == 0 { badUsage(programName, originalArgument); operationResult = 1; @@ -2417,36 +2404,29 @@ unsafe fn main_0( &raw mut argument, b"--memlimit\0" as *const u8 as *const core::ffi::c_char, ) != 0 - { - NEXT_UINT32!(memLimit); - } else if longCommandWArg( - &raw mut argument, - b"--memory\0" as *const u8 as *const core::ffi::c_char, - ) != 0 - { - NEXT_UINT32!(memLimit); - } else if longCommandWArg( - &raw mut argument, - b"--memlimit-decompress\0" as *const u8 as *const core::ffi::c_char, - ) != 0 + || longCommandWArg( + &raw mut argument, + b"--memory\0" as *const u8 as *const core::ffi::c_char, + ) != 0 + || longCommandWArg( + &raw mut argument, + b"--memlimit-decompress\0" as *const u8 + as *const core::ffi::c_char, + ) != 0 { NEXT_UINT32!(memLimit); } else if longCommandWArg( &raw mut argument, b"--block-size\0" as *const u8 as *const core::ffi::c_char, ) != 0 - { - NEXT_TSIZE!(chunkSize); - } else if longCommandWArg( - &raw mut argument, - b"--split\0" as *const u8 as *const core::ffi::c_char, - ) != 0 - { - NEXT_TSIZE!(chunkSize); - } else if longCommandWArg( - &raw mut argument, - b"--jobsize\0" as *const u8 as *const core::ffi::c_char, - ) != 0 + || longCommandWArg( + &raw mut argument, + b"--split\0" as *const u8 as *const core::ffi::c_char, + ) != 0 + || longCommandWArg( + &raw mut argument, + b"--jobsize\0" as *const u8 as *const core::ffi::c_char, + ) != 0 { NEXT_TSIZE!(chunkSize); } else if longCommandWArg( From 707033ec11ef874840816655b92a93a8130ed8fd Mon Sep 17 00:00:00 2001 From: Mattias Wallin Date: Sat, 6 Jun 2026 09:22:12 +0200 Subject: [PATCH 11/16] Fix clippy::wildcard_in_or_patterns --- programs/fileio.rs | 4 ++-- programs/main.rs | 1 + 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/programs/fileio.rs b/programs/fileio.rs index 309b09f5..98959182 100644 --- a/programs/fileio.rs +++ b/programs/fileio.rs @@ -4533,7 +4533,7 @@ unsafe fn FIO_compressFilename_internal( } exit(20); } - 0 | _ => { + _ => { compressedfilesize = FIO_compressZstdFrame( fCtx, prefs, @@ -7370,7 +7370,7 @@ unsafe fn FIO_listFile( } return 1; } - 0 | _ => {} + _ => {} } displayInfo(inFileName, &raw const info, displayLevel); *total = FIO_addFInfo(*total, info); diff --git a/programs/main.rs b/programs/main.rs index 41da7127..da2fb504 100644 --- a/programs/main.rs +++ b/programs/main.rs @@ -15,6 +15,7 @@ #![warn(clippy::double_parens)] #![warn(clippy::redundant_field_names)] #![warn(clippy::if_same_then_else)] +#![warn(clippy::wildcard_in_or_patterns)] extern crate libc; pub mod benchfn; From b0502e8e86c67bb0455f43007764cc2d70c56f9e Mon Sep 17 00:00:00 2001 From: Mattias Wallin Date: Sat, 6 Jun 2026 09:54:48 +0200 Subject: [PATCH 12/16] Fix clippy::collapsible_if --- programs/main.rs | 1 + programs/zstdcli.rs | 18 +++++++++--------- 2 files changed, 10 insertions(+), 9 deletions(-) diff --git a/programs/main.rs b/programs/main.rs index da2fb504..bdc4f69c 100644 --- a/programs/main.rs +++ b/programs/main.rs @@ -16,6 +16,7 @@ #![warn(clippy::redundant_field_names)] #![warn(clippy::if_same_then_else)] #![warn(clippy::wildcard_in_or_patterns)] +#![warn(clippy::collapsible_if)] extern crate libc; pub mod benchfn; diff --git a/programs/zstdcli.rs b/programs/zstdcli.rs index 300d109d..f6dcb161 100644 --- a/programs/zstdcli.rs +++ b/programs/zstdcli.rs @@ -3154,20 +3154,20 @@ unsafe fn main_0( } cLevel = maxCLevel; } - if showDefaultCParams != 0 { - if operation as core::ffi::c_uint + if showDefaultCParams != 0 + && operation as core::ffi::c_uint == zom_decompress as core::ffi::c_int as core::ffi::c_uint - { - if g_displayLevel >= 1 { - fprintf( + { + if g_displayLevel >= 1 { + fprintf( stderr, b"error : can't use --show-default-cparams in decompression mode \n\0" - as *const u8 as *const core::ffi::c_char, + as *const u8 + as *const core::ffi::c_char, ); - } - operationResult = 1; - break 'end; } + operationResult = 1; + break 'end; } if !dictFileName.is_null() && !patchFromDictFileName.is_null() { if g_displayLevel >= 1 { From b92859cf49f990a66c2741f84df4b809a4c66dff Mon Sep 17 00:00:00 2001 From: Mattias Wallin Date: Sat, 6 Jun 2026 09:57:35 +0200 Subject: [PATCH 13/16] Fix clippy::assertions_on_constants --- programs/fileio_asyncio.rs | 2 +- programs/main.rs | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/programs/fileio_asyncio.rs b/programs/fileio_asyncio.rs index d2025a56..f755352e 100644 --- a/programs/fileio_asyncio.rs +++ b/programs/fileio_asyncio.rs @@ -531,7 +531,7 @@ unsafe fn AIO_IOPool_createThreadPool(ctx: *mut IOPoolCtx_t, prefs: *const FIO_p } exit(102); } - assert!(MAX_IO_JOBS >= 2); + const { assert!(MAX_IO_JOBS >= 2) }; (*ctx).threadPool = POOL_create(1, (MAX_IO_JOBS - 2) as size_t); (*ctx).threadPoolActive = 1; if ((*ctx).threadPool).is_null() { diff --git a/programs/main.rs b/programs/main.rs index bdc4f69c..fdfe205f 100644 --- a/programs/main.rs +++ b/programs/main.rs @@ -17,6 +17,7 @@ #![warn(clippy::if_same_then_else)] #![warn(clippy::wildcard_in_or_patterns)] #![warn(clippy::collapsible_if)] +#![warn(clippy::assertions_on_constants)] extern crate libc; pub mod benchfn; From d1304fb776b03a80989524a1aecddda05dc9de0e Mon Sep 17 00:00:00 2001 From: Mattias Wallin Date: Sat, 6 Jun 2026 17:12:37 +0200 Subject: [PATCH 14/16] Fix unused_assignments lint --- c2rust-lib.rs | 1 - lib/common/entropy_common.rs | 27 +- lib/common/fse_decompress.rs | 18 +- lib/common/pool.rs | 3 +- lib/compress/fse_compress.rs | 27 +- lib/compress/hist.rs | 2 - lib/compress/huf_compress.rs | 62 ++--- lib/compress/zstd_compress.rs | 334 +++++++++------------- lib/compress/zstd_compress_literals.rs | 9 +- lib/compress/zstd_compress_sequences.rs | 8 +- lib/compress/zstd_compress_superblock.rs | 26 +- lib/compress/zstd_double_fast.rs | 34 +-- lib/compress/zstd_fast.rs | 81 ++---- lib/compress/zstd_lazy.rs | 42 ++- lib/compress/zstd_ldm.rs | 48 +--- lib/compress/zstd_opt.rs | 74 ++--- lib/compress/zstd_preSplit.rs | 3 +- lib/compress/zstdmt_compress.rs | 56 ++-- lib/decompress/huf_decompress.rs | 13 +- lib/decompress/zstd_decompress.rs | 11 +- lib/decompress/zstd_decompress_block.rs | 2 +- lib/dictBuilder/cover.rs | 49 ++-- lib/dictBuilder/divsufsort.rs | 40 +-- lib/dictBuilder/fastcover.rs | 14 +- lib/dictBuilder/zdict.rs | 27 +- lib/legacy/zstd_v05.rs | 89 +++--- lib/legacy/zstd_v06.rs | 169 ++++-------- lib/legacy/zstd_v07.rs | 51 ++-- programs/benchfn.rs | 7 +- programs/benchzstd.rs | 61 ++--- programs/datagen.rs | 1 - programs/dibio.rs | 32 +-- programs/fileio.rs | 335 +++++++++-------------- programs/fileio_asyncio.rs | 23 +- programs/lorem.rs | 15 +- programs/main.rs | 1 - programs/timefn.rs | 3 +- programs/util.rs | 160 ++++------- programs/zstdcli.rs | 29 +- 39 files changed, 688 insertions(+), 1299 deletions(-) diff --git a/c2rust-lib.rs b/c2rust-lib.rs index da55ef8e..efc392d0 100644 --- a/c2rust-lib.rs +++ b/c2rust-lib.rs @@ -34,7 +34,6 @@ #![allow(non_camel_case_types)] #![allow(non_snake_case)] #![allow(non_upper_case_globals)] -#![allow(unused_assignments)] #![allow(clippy::too_many_arguments)] #![cfg_attr(all(feature = "nightly", test), feature(test))] #![cfg_attr(feature = "nightly", feature(likely_unlikely))] diff --git a/lib/common/entropy_common.rs b/lib/common/entropy_common.rs index 3d479675..474a8278 100644 --- a/lib/common/entropy_common.rs +++ b/lib/common/entropy_common.rs @@ -21,11 +21,6 @@ fn FSE_readNCount_body( let iend = hbSize; let mut ip = 0usize; - let mut nbBits: core::ffi::c_int = 0; - let mut remaining: core::ffi::c_int = 0; - let mut threshold: core::ffi::c_int = 0; - let mut bitStream: u32 = 0; - let mut bitCount: core::ffi::c_int = 0; let mut charnum = 0 as core::ffi::c_uint; let maxSV1 = (*maxSVPtr).wrapping_add(1); let mut previous_was_0 = false; @@ -45,17 +40,17 @@ fn FSE_readNCount_body( let read_u32_le = |offset| u32::from_le_bytes(headerBuffer[offset..][..4].try_into().unwrap()); - bitStream = read_u32_le(ip); - nbBits = (bitStream & 0xf as core::ffi::c_int as u32).wrapping_add(FSE_MIN_TABLELOG as u32) - as core::ffi::c_int; + let mut bitStream = read_u32_le(ip); + let mut nbBits = (bitStream & 0xf as core::ffi::c_int as u32) + .wrapping_add(FSE_MIN_TABLELOG as u32) as core::ffi::c_int; if nbBits > FSE_TABLELOG_ABSOLUTE_MAX { return Err(Error::tableLog_tooLarge); } bitStream >>= 4; - bitCount = 4; + let mut bitCount: core::ffi::c_int = 4; *tableLogPtr = nbBits as core::ffi::c_uint; - remaining = (1 << nbBits) + 1; - threshold = 1 << nbBits; + let mut remaining: core::ffi::c_int = (1 << nbBits) + 1; + let mut threshold: core::ffi::c_int = 1 << nbBits; nbBits += 1; loop { if previous_was_0 { @@ -109,7 +104,7 @@ fn FSE_readNCount_body( } let max = 2 * threshold - 1 - remaining; - let mut count: core::ffi::c_int = 0; + let mut count: core::ffi::c_int; if (bitStream & (threshold - 1) as u32) < max as u32 { count = (bitStream & (threshold - 1) as u32) as core::ffi::c_int; bitCount += nbBits - 1; @@ -267,13 +262,11 @@ fn HUF_readStats_body( ) -> Result { let srcSize = ip.len(); - let mut weightTotal: u32 = 0; - let mut iSize: size_t = 0; - let mut oSize: size_t = 0; if srcSize == 0 { return Err(Error::srcSize_wrong); } - iSize = ip[0] as usize; + let mut iSize: size_t = ip[0] as usize; + let oSize: size_t; if iSize >= 128 { // Special header case. oSize = iSize.wrapping_sub(127); @@ -308,7 +301,7 @@ fn HUF_readStats_body( // Collect weight stats. rankStats[..HUF_TABLELOG_MAX + 1].fill(0); - weightTotal = 0; + let mut weightTotal: u32 = 0; for weight in huffWeight[..oSize as usize].iter() { let Some(rank_stat) = rankStats.get_mut(usize::from(*weight)) else { return Err(Error::corruption_detected); diff --git a/lib/common/fse_decompress.rs b/lib/common/fse_decompress.rs index 178b9b80..b71e1db8 100644 --- a/lib/common/fse_decompress.rs +++ b/lib/common/fse_decompress.rs @@ -9,12 +9,6 @@ use crate::lib::common::{ error_private::Error, }; -#[derive(Copy, Clone, Debug, PartialEq)] -#[repr(C, align(4))] -pub(crate) struct FSE_DTable { - pub header: FSE_DTableHeader, -} - #[derive(Copy, Clone, Debug, PartialEq)] #[repr(C)] pub(crate) struct FSE_DecompressWksp { @@ -109,7 +103,6 @@ fn FSE_buildDTable_internal( let largeLimit = ((1) << tableLog.wrapping_sub(1)) as i16; let mut s: u32 = 0; - s = 0; while s < maxSV1 { if normalizedCounter[s as usize] as core::ffi::c_int == -(1) { let fresh0 = highThreshold; @@ -137,10 +130,9 @@ fn FSE_buildDTable_internal( let mut sv = 0u64; for s_0 in 0..maxSV1 { - let mut i: core::ffi::c_int = 0; let n = normalizedCounter[s_0 as usize] as core::ffi::c_int; spread[pos as usize..][..8].copy_from_slice(&sv.to_le_bytes()); - i = 8; + let mut i: core::ffi::c_int = 8; while i < n { spread[pos as usize..][i as usize..][..8].copy_from_slice(&sv.to_le_bytes()); i += 8; @@ -152,10 +144,8 @@ fn FSE_buildDTable_internal( let mut position = 0 as size_t; let mut s_1: size_t = 0; let unroll = 2; - s_1 = 0; while s_1 < tableSize as size_t { let mut u: size_t = 0; - u = 0; while u < unroll { let uPosition = position.wrapping_add(u * step) & tableMask; elements[uPosition as usize].symbol = spread[(s_1 + u) as usize]; @@ -325,7 +315,7 @@ fn FSE_decompress_wksp_body( workspace: &mut Workspace, bmi2: core::ffi::c_int, ) -> Result { - let mut wkspSize = size_of::(); + let wkspSize = size_of::(); let mut tableLog: core::ffi::c_uint = 0; let mut maxSymbolValue = FSE_MAX_SYMBOL_VALUE as core::ffi::c_uint; @@ -371,10 +361,6 @@ fn FSE_decompress_wksp_body( { return Err(Error::tableLog_tooLarge); } - wkspSize = wkspSize.wrapping_sub( - size_of::() - .wrapping_add((1usize + (1 << tableLog)).wrapping_mul(size_of::())), - ); let () = FSE_buildDTable_internal( &mut workspace.dtable, diff --git a/lib/common/pool.rs b/lib/common/pool.rs index c3f13317..bbd6d484 100644 --- a/lib/common/pool.rs +++ b/lib/common/pool.rs @@ -73,11 +73,10 @@ pub(crate) unsafe fn POOL_create_advanced( queueSize: size_t, customMem: ZSTD_customMem, ) -> *mut POOL_ctx { - let mut ctx = core::ptr::null_mut::(); if numThreads == 0 { return core::ptr::null_mut(); } - ctx = ZSTD_customCalloc(size_of::(), customMem) as *mut POOL_ctx; + let ctx = ZSTD_customCalloc(size_of::(), customMem) as *mut POOL_ctx; if ctx.is_null() { return core::ptr::null_mut(); } diff --git a/lib/compress/fse_compress.rs b/lib/compress/fse_compress.rs index 4d43ceea..5b124870 100644 --- a/lib/compress/fse_compress.rs +++ b/lib/compress/fse_compress.rs @@ -90,9 +90,8 @@ pub(crate) unsafe fn FSE_buildCTable_wksp( } *tableU16.sub(2) = tableLog as u16; *tableU16.sub(1) = maxSymbolValue as u16; - let mut u: u32 = 0; *cumul = 0; - u = 1; + let mut u: u32 = 1; while u <= maxSV1 { if *normalizedCounter.offset(u.wrapping_sub(1) as isize) as core::ffi::c_int == -(1) { *cumul.offset(u as isize) = @@ -115,12 +114,10 @@ pub(crate) unsafe fn FSE_buildCTable_wksp( let mut pos = 0 as size_t; let mut sv = 0u64; let mut s: u32 = 0; - s = 0; while s < maxSV1 { - let mut i: core::ffi::c_int = 0; let n = *normalizedCounter.offset(s as isize) as core::ffi::c_int; MEM_write64(spread.add(pos) as *mut core::ffi::c_void, sv); - i = 8; + let mut i: core::ffi::c_int = 8; while i < n { MEM_write64( spread.add(pos).offset(i as isize) as *mut core::ffi::c_void, @@ -135,10 +132,8 @@ pub(crate) unsafe fn FSE_buildCTable_wksp( let mut position = 0 as size_t; let mut s_0: size_t = 0; let unroll = 2; - s_0 = 0; while s_0 < tableSize as size_t { let mut u_0: size_t = 0; - u_0 = 0; while u_0 < unroll { let uPosition = position.wrapping_add(u_0 * step as size_t) & tableMask as size_t; *tableSymbol.add(uPosition) = *spread.add(s_0.wrapping_add(u_0)); @@ -150,11 +145,9 @@ pub(crate) unsafe fn FSE_buildCTable_wksp( } else { let mut position_0 = 0u32; let mut symbol: u32 = 0; - symbol = 0; while symbol < maxSV1 { let mut nbOccurrences: core::ffi::c_int = 0; let freq = *normalizedCounter.offset(symbol as isize) as core::ffi::c_int; - nbOccurrences = 0; while nbOccurrences < freq { *tableSymbol.offset(position_0 as isize) = symbol as u8; position_0 = position_0.wrapping_add(step) & tableMask; @@ -167,7 +160,6 @@ pub(crate) unsafe fn FSE_buildCTable_wksp( } } let mut u_1: u32 = 0; - u_1 = 0; while u_1 < tableSize { let s_1 = *tableSymbol.offset(u_1 as isize); let fresh1 = &mut (*cumul.offset(s_1 as isize)); @@ -178,7 +170,6 @@ pub(crate) unsafe fn FSE_buildCTable_wksp( } let mut total = 0 as core::ffi::c_uint; let mut s_2: core::ffi::c_uint = 0; - s_2 = 0; while s_2 <= maxSymbolValue { match *normalizedCounter.offset(s_2 as isize) as core::ffi::c_int { 0 => { @@ -239,10 +230,7 @@ unsafe fn FSE_writeNCount_generic( let ostart = header as *mut u8; let mut out = ostart; let oend = ostart.add(headerBufferSize); - let mut nbBits: core::ffi::c_int = 0; let tableSize = (1) << tableLog; - let mut remaining: core::ffi::c_int = 0; - let mut threshold: core::ffi::c_int = 0; let mut bitStream = 0; let mut bitCount = 0; let mut symbol = 0; @@ -251,9 +239,9 @@ unsafe fn FSE_writeNCount_generic( bitStream = (bitStream as core::ffi::c_uint) .wrapping_add(tableLog.wrapping_sub(FSE_MIN_TABLELOG as core::ffi::c_uint) << bitCount); bitCount += 4; - remaining = tableSize + 1; - threshold = tableSize; - nbBits = tableLog as core::ffi::c_int + 1; + let mut remaining = tableSize + 1; + let mut threshold = tableSize; + let mut nbBits = tableLog as core::ffi::c_int + 1; while symbol < alphabetSize && remaining > 1 { if previousIs0 != 0 { let mut start = symbol; @@ -421,10 +409,8 @@ unsafe fn FSE_normalizeM2( let NOT_YET_ASSIGNED = -(2) as core::ffi::c_short; let mut s: u32 = 0; let mut distributed = 0u32; - let mut ToDistribute: u32 = 0; let lowThreshold = (total >> tableLog) as u32; let mut lowOne = ((total * 3) >> tableLog.wrapping_add(1)) as u32; - s = 0; while s <= maxSymbolValue { if *count.offset(s as isize) == 0 { *norm.offset(s as isize) = 0; @@ -441,7 +427,7 @@ unsafe fn FSE_normalizeM2( } s = s.wrapping_add(1); } - ToDistribute = ((1 << tableLog) as u32).wrapping_sub(distributed); + let mut ToDistribute = ((1 << tableLog) as u32).wrapping_sub(distributed); if ToDistribute == 0 { return 0; } @@ -540,7 +526,6 @@ pub(crate) unsafe fn FSE_normalizeCount( let mut largest = 0; let mut largestP = 0; let lowThreshold = (total >> tableLog) as u32; - s = 0; while s <= maxSymbolValue { if *count.offset(s as isize) as size_t == total { return 0; diff --git a/lib/compress/hist.rs b/lib/compress/hist.rs index 4e278f02..3ca6a2e3 100644 --- a/lib/compress/hist.rs +++ b/lib/compress/hist.rs @@ -60,7 +60,6 @@ pub unsafe fn HIST_count_simple( } *maxSymbolValuePtr = maxSymbolValue; let mut s: u32 = 0; - s = 0; while s <= maxSymbolValue { if *count.offset(s as isize) > largestCount { largestCount = *count.offset(s as isize); @@ -154,7 +153,6 @@ unsafe fn HIST_count_parallel_wksp( *fresh21 = (*fresh21).wrapping_add(1); } let mut s: u32 = 0; - s = 0; while s < 256 { let fresh22 = &mut (*Counting1.offset(s as isize)); *fresh22 = (*fresh22).wrapping_add( diff --git a/lib/compress/huf_compress.rs b/lib/compress/huf_compress.rs index 31939a8b..be544783 100644 --- a/lib/compress/huf_compress.rs +++ b/lib/compress/huf_compress.rs @@ -272,7 +272,6 @@ pub unsafe fn HUF_writeCTable_wksp( ) -> size_t { let ct = CTable.add(1); let op = dst as *mut u8; - let mut n: u32 = 0; let wksp = HUF_alignUpWorkspace(workspace, &mut workspaceSize, align_of::() as size_t) as *mut HUF_WriteCTableWksp; @@ -293,7 +292,7 @@ pub unsafe fn HUF_writeCTable_wksp( /* convert to weight */ *((*wksp).bitsToWeight).as_mut_ptr() = 0; - n = 1; + let mut n: u32 = 1; while n < huffLog + 1 { *((*wksp).bitsToWeight).as_mut_ptr().offset(n as isize) = (huffLog + 1 - n) as u8; n += 1; @@ -395,9 +394,8 @@ pub unsafe fn HUF_readCTable( /* Prepare base value per rank */ { - let mut n: u32 = 0; let mut nextRankStart = 0u32; - n = 1; + let mut n: u32 = 1; while n <= tableLog { let curr = nextRankStart; nextRankStart += *rankVal.as_mut_ptr().offset(n as isize) << (n - 1); @@ -409,7 +407,6 @@ pub unsafe fn HUF_readCTable( /* fill nbBits */ { let mut n_0: u32 = 0; - n_0 = 0; while n_0 < nbSymbols { let w = *huffWeight.as_mut_ptr().offset(n_0 as isize) as u32; HUF_setNbBits( @@ -426,7 +423,6 @@ pub unsafe fn HUF_readCTable( let mut valPerRank: [u16; HUF_TABLELOG_MAX + 2] = [0; HUF_TABLELOG_MAX + 2]; let mut n_1: u32 = 0; { - n_1 = 0; while n_1 < nbSymbols { let fresh0 = &mut (*nbPerRank .as_mut_ptr() @@ -440,8 +436,7 @@ pub unsafe fn HUF_readCTable( { let mut min = 0; - let mut n_2: u32 = 0; - n_2 = tableLog; + let mut n_2 = tableLog; while n_2 > 0 { /* start at n=tablelog <-> w=1 */ *valPerRank.as_mut_ptr().offset(n_2 as isize) = min; /* get starting value within each rank */ @@ -454,7 +449,6 @@ pub unsafe fn HUF_readCTable( /* assign value within rank, symbol order */ { let mut n_3: u32 = 0; - n_3 = 0; while n_3 < nbSymbols { let fresh1 = &mut (*valPerRank .as_mut_ptr() @@ -555,8 +549,7 @@ unsafe fn HUF_setMaxHeight(huffNode: *mut nodeElt, lastNonNull: u32, targetNbBit ); { let mut currentNbBits = targetNbBits; - let mut pos: c_int = 0; - pos = n; + let mut pos = n; while pos >= 0 { if ((*huffNode.offset(pos as isize)).nbBits as u32) < currentNbBits { currentNbBits = (*huffNode.offset(pos as isize)).nbBits as u32; /* < targetNbBits */ @@ -743,10 +736,9 @@ unsafe fn HUF_isSorted(huffNode: *mut nodeElt, maxSymbolValue1: u32) -> c_int { /// Insertion sort by descending order #[inline(always)] unsafe fn HUF_insertionSort(mut huffNode: *mut nodeElt, low: c_int, high: c_int) { - let mut i: c_int = 0; let size = high - low + 1; huffNode = huffNode.offset(low as isize); - i = 1; + let mut i: c_int = 1; while i < size { let key = *huffNode.offset(i as isize); let mut j = i - 1; @@ -819,7 +811,6 @@ unsafe fn HUF_sort( maxSymbolValue: u32, rankPosition: *mut rankPos, ) { - let mut n: u32 = 0; let maxSymbolValue1 = maxSymbolValue + 1; /* Compute base and set curr to base. * For symbol s let lowerRank = HUF_getIndex(count[n]) and rank = lowerRank + 1. @@ -828,7 +819,7 @@ unsafe fn HUF_sort( * each rank begins in the output, so for rank R we want to count ranks R+1 and above. */ ptr::write_bytes(rankPosition as *mut u8, 0, size_of::() * 192); - n = 0; + let mut n: u32 = 0; while n < maxSymbolValue1 { let lowerRank = HUF_getIndex(*count.offset(n as isize)); let fresh8 = &mut (*rankPosition.offset(lowerRank as isize)).base; @@ -892,21 +883,16 @@ pub const STARTNODE: c_int = HUF_SYMBOLVALUE_MAX as i32 + 1; /// The smallest node in the Huffman tree (by count). unsafe fn HUF_buildTree(huffNode: *mut nodeElt, maxSymbolValue: u32) -> c_int { let huffNode0 = huffNode.sub(1); - let mut nonNullRank: c_int = 0; - let mut lowS: c_int = 0; - let mut lowN: c_int = 0; let mut nodeNb = STARTNODE; - let mut n: c_int = 0; - let mut nodeRoot: c_int = 0; /* init for parents */ - nonNullRank = maxSymbolValue as c_int; + let mut nonNullRank = maxSymbolValue as c_int; while (*huffNode.offset(nonNullRank as isize)).count == 0 { nonNullRank -= 1; } - lowS = nonNullRank; - nodeRoot = nodeNb + lowS - 1; - lowN = nodeNb; + let mut lowS = nonNullRank; + let nodeRoot = nodeNb + lowS - 1; + let mut lowN = nodeNb; (*huffNode.offset(nodeNb as isize)).count = ((*huffNode.offset(lowS as isize)).count) + ((*huffNode.offset((lowS - 1) as isize)).count); let fresh12 = &mut (*huffNode.offset((lowS - 1) as isize)).parent; @@ -914,7 +900,7 @@ unsafe fn HUF_buildTree(huffNode: *mut nodeElt, maxSymbolValue: u32) -> c_int { (*huffNode.offset(lowS as isize)).parent = *fresh12; nodeNb += 1; lowS -= 2; - n = nodeNb; + let mut n = nodeNb; while n <= nodeRoot { (*huffNode.offset(n as isize)).count = 1 << 30; n += 1; @@ -990,11 +976,10 @@ unsafe fn HUF_buildCTableFromTree( ) { /* fill result into ctable (val, nbBits) */ let ct = CTable.add(1); - let mut n: c_int = 0; let mut nbPerRank: [u16; HUF_TABLELOG_MAX + 1] = [0; HUF_TABLELOG_MAX + 1]; let mut valPerRank: [u16; HUF_TABLELOG_MAX + 1] = [0; HUF_TABLELOG_MAX + 1]; let alphabetSize = (maxSymbolValue + 1) as c_int; - n = 0; + let mut n: c_int = 0; while n <= nonNullRank { let fresh18 = &mut (*nbPerRank .as_mut_ptr() @@ -1048,7 +1033,6 @@ pub unsafe fn HUF_buildCTable_wksp( as *mut HUF_buildCTable_wksp_tables; let huffNode0 = ((*wksp_tables).huffNodeTbl).as_mut_ptr(); let huffNode = huffNode0.add(1); - let mut nonNullRank: c_int = 0; const { assert!(HUF_CTABLE_WORKSPACE_SIZE == size_of::()); @@ -1074,7 +1058,7 @@ pub unsafe fn HUF_buildCTable_wksp( ); /* build tree */ - nonNullRank = HUF_buildTree(huffNode, maxSymbolValue); + let nonNullRank = HUF_buildTree(huffNode, maxSymbolValue); /* determine and enforce maxTableLog */ maxNbBits = HUF_setMaxHeight(huffNode, nonNullRank as u32, maxNbBits); @@ -1093,7 +1077,6 @@ pub unsafe fn HUF_estimateCompressedSize( let ct = CTable.add(1); let mut nbBits = 0 as size_t; let mut s: c_int = 0; - s = 0; while s <= maxSymbolValue as c_int { nbBits += HUF_getNbBits(*ct.offset(s as isize)) * *count.offset(s as isize) as size_t; s += 1; @@ -1109,14 +1092,13 @@ pub unsafe fn HUF_validateCTable( let header = HUF_readCTableHeader(CTable); let ct = CTable.add(1); let mut bad = 0; - let mut s: c_int = 0; debug_assert!(header.tableLog as usize <= HUF_TABLELOG_ABSOLUTEMAX); if (header.maxSymbolValue as c_uint) < maxSymbolValue { return 0; } - s = 0; + let mut s: c_int = 0; while s <= maxSymbolValue as c_int { bad |= (*count.offset(s as isize) != 0) as c_int & (HUF_getNbBits(*ct.offset(s as isize)) == 0) as c_int; @@ -1327,8 +1309,7 @@ unsafe fn HUF_compress1X_usingCTable_internal_body_loop( /* Join to 2 * kUnroll */ if n % (2 * kUnroll) != 0 { - let mut u: c_int = 0; - u = 1; + let mut u: c_int = 1; while u < kUnroll { HUF_encodeSymbol(bitC, *ip.offset((n - u) as isize) as u32, ct, 0, 1); u += 1; @@ -1347,8 +1328,7 @@ unsafe fn HUF_compress1X_usingCTable_internal_body_loop( while n > 0 { /* Encode kUnroll symbols into the bitstream @ index 0. */ - let mut u_0: c_int = 0; - u_0 = 1; + let mut u_0: c_int = 1; while u_0 < kUnroll { HUF_encodeSymbol(bitC, *ip.offset((n - u_0) as isize) as u32, ct, 0, 1); u_0 += 1; @@ -1724,7 +1704,6 @@ pub const SUSPECT_INCOMPRESSIBLE_SAMPLE_RATIO: c_int = 10; /* Must be >= 2 */ pub unsafe fn HUF_cardinality(count: *const c_uint, maxSymbolValue: c_uint) -> c_uint { let mut cardinality = 0 as c_uint; let mut i: c_uint = 0; - i = 0; while i < maxSymbolValue + 1 { if *count.offset(i as isize) != 0 { cardinality += 1; @@ -1757,16 +1736,13 @@ pub unsafe fn HUF_optimalTableLog( } let dst = (workSpace as *mut u8).offset(size_of::() as c_ulong as isize); let dstSize = wkspSize - size_of::(); - let mut hSize: size_t = 0; - let mut newSize: size_t = 0; let symbolCardinality = HUF_cardinality(count, maxSymbolValue); let minTableLog = HUF_minTableLog(symbolCardinality); let mut optSize = (!(0) as size_t) - 1; let mut optLog = maxTableLog; - let mut optLogGuess: c_uint = 0; /* Search until size increases */ - optLogGuess = minTableLog; + let mut optLogGuess = minTableLog; while optLogGuess <= maxTableLog { let maxBits = HUF_buildCTable_wksp( table, @@ -1780,7 +1756,7 @@ pub unsafe fn HUF_optimalTableLog( if maxBits < optLogGuess as size_t && optLogGuess > minTableLog { break; } - hSize = HUF_writeCTable_wksp( + let hSize = HUF_writeCTable_wksp( dst as *mut c_void, dstSize, table, @@ -1790,7 +1766,7 @@ pub unsafe fn HUF_optimalTableLog( wkspSize, ); if !ERR_isError(hSize) { - newSize = (HUF_estimateCompressedSize(table, count, maxSymbolValue)) + (hSize); + let newSize = (HUF_estimateCompressedSize(table, count, maxSymbolValue)) + (hSize); if newSize > optSize + 1 { break; } diff --git a/lib/compress/zstd_compress.rs b/lib/compress/zstd_compress.rs index efd2291b..fc8d0584 100644 --- a/lib/compress/zstd_compress.rs +++ b/lib/compress/zstd_compress.rs @@ -1070,12 +1070,10 @@ unsafe fn ZSTD_cwksp_reserve_internal( bytes: size_t, phase: ZSTD_cwksp_alloc_phase_e, ) -> *mut core::ffi::c_void { - let mut alloc = core::ptr::null_mut::(); if ERR_isError(ZSTD_cwksp_internal_advance_phase(ws, phase)) || bytes == 0 { return core::ptr::null_mut(); } - alloc = ZSTD_cwksp_reserve_internal_buffer_space(ws, bytes); - alloc + ZSTD_cwksp_reserve_internal_buffer_space(ws, bytes) } #[inline] unsafe fn ZSTD_cwksp_reserve_buffer(ws: *mut ZSTD_cwksp, bytes: size_t) -> *mut u8 { @@ -1120,17 +1118,14 @@ unsafe fn ZSTD_cwksp_reserve_aligned64( #[inline] unsafe fn ZSTD_cwksp_reserve_table(ws: *mut ZSTD_cwksp, bytes: size_t) -> *mut core::ffi::c_void { let phase = ZSTD_cwksp_alloc_aligned_init_once; - let mut alloc = core::ptr::null_mut::(); - let mut end = core::ptr::null_mut::(); - let mut top = core::ptr::null_mut::(); if ((*ws).phase as core::ffi::c_uint) < phase as core::ffi::c_uint && ERR_isError(ZSTD_cwksp_internal_advance_phase(ws, phase)) { return core::ptr::null_mut(); } - alloc = (*ws).tableEnd; - end = (alloc as *mut u8).add(bytes) as *mut core::ffi::c_void; - top = (*ws).allocStart; + let alloc = (*ws).tableEnd; + let end = (alloc as *mut u8).add(bytes) as *mut core::ffi::c_void; + let top = (*ws).allocStart; ZSTD_cwksp_assert_internal_consistency(ws); if end > top { (*ws).allocFailed = 1; @@ -1617,7 +1612,6 @@ pub unsafe extern "C" fn ZSTD_initStaticCCtx( phase: ZSTD_cwksp_alloc_objects, isStatic: ZSTD_cwksp_dynamic_alloc, }; - let mut cctx = core::ptr::null_mut::(); if workspaceSize <= size_of::() { return core::ptr::null_mut(); } @@ -1625,7 +1619,7 @@ pub unsafe extern "C" fn ZSTD_initStaticCCtx( return core::ptr::null_mut(); } ZSTD_cwksp_init(&mut ws, workspace, workspaceSize, ZSTD_cwksp_static_alloc); - cctx = ZSTD_cwksp_reserve_object(&mut ws, size_of::()) as *mut ZSTD_CCtx; + let cctx = ZSTD_cwksp_reserve_object(&mut ws, size_of::()) as *mut ZSTD_CCtx; if cctx.is_null() { return core::ptr::null_mut(); } @@ -3012,11 +3006,10 @@ pub unsafe extern "C" fn ZSTD_CCtx_loadDictionary_advanced( { (*cctx).localDict.dict = dict; } else { - let mut dictBuffer = core::ptr::null_mut::(); if (*cctx).staticSize != 0 { return Error::memory_allocation.to_error_code(); } - dictBuffer = ZSTD_customMalloc(dictSize, (*cctx).customMem); + let dictBuffer = ZSTD_customMalloc(dictSize, (*cctx).customMem); if dictBuffer.is_null() { return Error::memory_allocation.to_error_code(); } @@ -3387,21 +3380,12 @@ pub unsafe extern "C" fn ZSTD_getCParamsFromCCtxParams( dictSize: size_t, mode: ZSTD_CParamMode_e, ) -> ZSTD_compressionParameters { - let mut cParams = ZSTD_compressionParameters { - windowLog: 0, - chainLog: 0, - hashLog: 0, - searchLog: 0, - minMatch: 0, - targetLength: 0, - strategy: 0, - }; if srcSizeHint as core::ffi::c_ulonglong == ZSTD_CONTENTSIZE_UNKNOWN && (*CCtxParams).srcSizeHint > 0 { srcSizeHint = (*CCtxParams).srcSizeHint as u64; } - cParams = ZSTD_getCParams_internal( + let mut cParams = ZSTD_getCParams_internal( (*CCtxParams).compressionLevel, srcSizeHint as core::ffi::c_ulonglong, dictSize, @@ -3612,12 +3596,10 @@ pub unsafe extern "C" fn ZSTD_estimateCCtxSize_usingCParams( ) -> size_t { let mut initialParams = ZSTD_makeCCtxParamsFromCParams(cParams); if ZSTD_rowMatchFinderSupported(cParams.strategy) != 0 { - let mut noRowCCtxSize: size_t = 0; - let mut rowCCtxSize: size_t = 0; initialParams.useRowMatchFinder = ZSTD_ParamSwitch_e::ZSTD_ps_disable; - noRowCCtxSize = ZSTD_estimateCCtxSize_usingCCtxParams(&initialParams); + let noRowCCtxSize = ZSTD_estimateCCtxSize_usingCCtxParams(&initialParams); initialParams.useRowMatchFinder = ZSTD_ParamSwitch_e::ZSTD_ps_enable; - rowCCtxSize = ZSTD_estimateCCtxSize_usingCCtxParams(&initialParams); + let rowCCtxSize = ZSTD_estimateCCtxSize_usingCCtxParams(&initialParams); if noRowCCtxSize > rowCCtxSize { noRowCCtxSize } else { @@ -3654,9 +3636,8 @@ unsafe extern "C" fn ZSTD_estimateCCtxSize_internal(compressionLevel: core::ffi: } #[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_estimateCCtxSize))] pub unsafe extern "C" fn ZSTD_estimateCCtxSize(compressionLevel: core::ffi::c_int) -> size_t { - let mut level: core::ffi::c_int = 0; let mut memBudget = 0; - level = if compressionLevel < 1 { + let mut level = if compressionLevel < 1 { compressionLevel } else { 1 @@ -3718,12 +3699,10 @@ pub unsafe extern "C" fn ZSTD_estimateCStreamSize_usingCParams( ) -> size_t { let mut initialParams = ZSTD_makeCCtxParamsFromCParams(cParams); if ZSTD_rowMatchFinderSupported(cParams.strategy) != 0 { - let mut noRowCCtxSize: size_t = 0; - let mut rowCCtxSize: size_t = 0; initialParams.useRowMatchFinder = ZSTD_ParamSwitch_e::ZSTD_ps_disable; - noRowCCtxSize = ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams); + let noRowCCtxSize = ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams); initialParams.useRowMatchFinder = ZSTD_ParamSwitch_e::ZSTD_ps_enable; - rowCCtxSize = ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams); + let rowCCtxSize = ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams); if noRowCCtxSize > rowCCtxSize { noRowCCtxSize } else { @@ -3744,9 +3723,8 @@ unsafe fn ZSTD_estimateCStreamSize_internal(compressionLevel: core::ffi::c_int) } #[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_estimateCStreamSize))] pub unsafe extern "C" fn ZSTD_estimateCStreamSize(compressionLevel: core::ffi::c_int) -> size_t { - let mut level: core::ffi::c_int = 0; let mut memBudget = 0; - level = if compressionLevel < 1 { + let mut level = if compressionLevel < 1 { compressionLevel } else { 1 @@ -3813,7 +3791,6 @@ unsafe fn ZSTD_assertEqualCParams( } pub unsafe fn ZSTD_reset_compressedBlockState(bs: *mut ZSTD_compressedBlockState_t) { let mut i: core::ffi::c_int = 0; - i = 0; while i < ZSTD_REP_NUM { *((*bs).rep).as_mut_ptr().offset(i as isize) = *repStartValue.as_ptr().offset(i as isize); i += 1; @@ -4200,7 +4177,6 @@ unsafe fn ZSTD_resetCCtx_internal( } pub unsafe fn ZSTD_invalidateRepCodes(cctx: *mut ZSTD_CCtx) { let mut i: core::ffi::c_int = 0; - i = 0; while i < ZSTD_REP_NUM { *((*(*cctx).blockState.prevCBlock).rep) .as_mut_ptr() @@ -4292,7 +4268,6 @@ unsafe fn ZSTD_copyCDictTableIntoCCtx( ) { if ZSTD_CDictIndicesAreTagged(cParams) != 0 { let mut i: size_t = 0; - i = 0; while i < tableSize { let taggedIndex = *src.add(i); let index = taggedIndex >> ZSTD_SHORT_CACHE_TAG_BITS; @@ -4510,20 +4485,18 @@ unsafe fn ZSTD_reduceTable_internal( let mut cellNb = 0; let mut rowNb: core::ffi::c_int = 0; let reducerThreshold = reducerValue.wrapping_add(ZSTD_WINDOW_START_INDEX as u32); - rowNb = 0; while rowNb < nbRows { let mut column: core::ffi::c_int = 0; - column = 0; while column < ZSTD_ROWSIZE { - let mut newVal: u32 = 0; - if preserveMark != 0 && *table.offset(cellNb as isize) == ZSTD_DUBT_UNSORTED_MARK as u32 + let newVal = if preserveMark != 0 + && *table.offset(cellNb as isize) == ZSTD_DUBT_UNSORTED_MARK as u32 { - newVal = ZSTD_DUBT_UNSORTED_MARK as u32; + ZSTD_DUBT_UNSORTED_MARK as u32 } else if *table.offset(cellNb as isize) < reducerThreshold { - newVal = 0; + 0 } else { - newVal = (*table.offset(cellNb as isize)).wrapping_sub(reducerValue); - } + (*table.offset(cellNb as isize)).wrapping_sub(reducerValue) + }; *table.offset(cellNb as isize) = newVal; cellNb += 1; column += 1; @@ -4573,7 +4546,6 @@ pub unsafe fn ZSTD_seqToCodes(seqStorePtr: *const SeqStore_t) -> core::ffi::c_in as core::ffi::c_long as u32; let mut u: u32 = 0; let mut longOffsets = 0; - u = 0; while u < nbSeq { let llv = (*sequences.offset(u as isize)).litLength as u32; let ofCode = ZSTD_highbit32((*sequences.offset(u as isize)).offBase); @@ -4821,8 +4793,6 @@ unsafe fn ZSTD_entropyCompressSeqStore_internal( let ostart = dst as *mut u8; let oend = ostart.add(dstCapacity); let mut op = ostart; - let mut lastCountSize: size_t = 0; - let mut longOffsets = 0; entropyWorkspace = count.offset(((if 35 > 52 { 35 } else { 52 }) + 1) as isize) as *mut core::ffi::c_void; entropyWkspSize = (entropyWkspSize as size_t).wrapping_sub( @@ -4902,9 +4872,9 @@ unsafe fn ZSTD_entropyCompressSeqStore_internal( *seqHead = (stats.LLtype << 6) .wrapping_add(stats.Offtype << 4) .wrapping_add(stats.MLtype << 2) as u8; - lastCountSize = stats.lastCountSize; + let lastCountSize = stats.lastCountSize; op = op.add(stats.size); - longOffsets = stats.longOffsets; + let longOffsets = stats.longOffsets; let bitstreamSize = ZSTD_encodeSequences( op as *mut core::ffi::c_void, oend.offset_from_unsigned(op), @@ -5111,7 +5081,8 @@ pub unsafe fn ZSTD_selectBlockCompressor( None, ], ]; - let mut selectedCompressor: ZSTD_BlockCompressor_f = None; + + // Return the selected compressor if ZSTD_rowMatchFinderUsed(strat, useRowMatchFinder) != 0 { static rowBasedBlockCompressors: [[ZSTD_BlockCompressor_f; 3]; 4] = [ [ @@ -5135,19 +5106,18 @@ pub unsafe fn ZSTD_selectBlockCompressor( Some(ZSTD_COMPRESSBLOCK_LAZY2_DEDICATEDDICTSEARCH_ROW), ], ]; - selectedCompressor = *(*rowBasedBlockCompressors + *(*rowBasedBlockCompressors .as_ptr() .offset(dictMode as core::ffi::c_int as isize)) .as_ptr() - .offset((strat as core::ffi::c_int - ZSTD_greedy as core::ffi::c_int) as isize); + .offset((strat as core::ffi::c_int - ZSTD_greedy as core::ffi::c_int) as isize) } else { - selectedCompressor = *(*blockCompressor + *(*blockCompressor .as_ptr() .offset(dictMode as core::ffi::c_int as isize)) .as_ptr() - .offset(strat as core::ffi::c_int as isize); + .offset(strat as core::ffi::c_int as isize) } - selectedCompressor } unsafe fn ZSTD_storeLastLiterals( seqStorePtr: &mut SeqStore_t, @@ -5204,9 +5174,6 @@ unsafe fn ZSTD_fastSequenceLengthSum(seqBuf: *const ZSTD_Sequence, seqBufSize: s let mut matchLenSum: size_t = 0; let mut litLenSum: size_t = 0; let mut i: size_t = 0; - matchLenSum = 0; - litLenSum = 0; - i = 0; while i < seqBufSize { litLenSum = litLenSum.wrapping_add((*seqBuf.add(i)).litLength as size_t); matchLenSum = matchLenSum.wrapping_add((*seqBuf.add(i)).matchLength as size_t); @@ -5280,9 +5247,7 @@ unsafe fn ZSTD_buildSeqStore( /* select and store sequences */ let dictMode = ZSTD_matchState_dictMode(ms); - let mut lastLLSize: size_t = 0; let mut i: core::ffi::c_int = 0; - i = 0; while i < ZSTD_REP_NUM { *((*(*zc).blockState.nextCBlock).rep) .as_mut_ptr() @@ -5291,11 +5256,12 @@ unsafe fn ZSTD_buildSeqStore( .offset(i as isize); i += 1; } - if (*zc).externSeqStore.pos < (*zc).externSeqStore.size { + + let lastLLSize = if (*zc).externSeqStore.pos < (*zc).externSeqStore.size { if ZSTD_hasExtSeqProd(&(*zc).appliedParams) != 0 { return Error::parameter_combination_unsupported.to_error_code(); } - lastLLSize = ZSTD_ldm_blockCompress( + ZSTD_ldm_blockCompress( &mut (*zc).externSeqStore, ms, &mut (*zc).seqStore, @@ -5303,7 +5269,7 @@ unsafe fn ZSTD_buildSeqStore( (*zc).appliedParams.useRowMatchFinder, src, srcSize, - ); + ) } else if (*zc).appliedParams.ldmParams.enableLdm == ZSTD_ParamSwitch_e::ZSTD_ps_enable { let mut ldmSeqStore = kNullRawSeqStore; if ZSTD_hasExtSeqProd(&(*zc).appliedParams) != 0 { @@ -5321,7 +5287,7 @@ unsafe fn ZSTD_buildSeqStore( if ERR_isError(err_code) { return err_code; } - lastLLSize = ZSTD_ldm_blockCompress( + ZSTD_ldm_blockCompress( &mut ldmSeqStore, ms, &mut (*zc).seqStore, @@ -5329,7 +5295,7 @@ unsafe fn ZSTD_buildSeqStore( (*zc).appliedParams.useRowMatchFinder, src, srcSize, - ); + ) } else if ZSTD_hasExtSeqProd(&(*zc).appliedParams) != 0 { let windowSize = (1) << (*zc).appliedParams.cParams.windowLog; let nbExternalSeqs = ((*zc).appliedParams.extSeqProdFunc).unwrap_unchecked()( @@ -5385,13 +5351,13 @@ unsafe fn ZSTD_buildSeqStore( dictMode, ); ms.ldmSeqStore = core::ptr::null(); - lastLLSize = blockCompressor.unwrap_unchecked()( + blockCompressor.unwrap_unchecked()( ms, &mut (*zc).seqStore, ((*(*zc).blockState.nextCBlock).rep).as_mut_ptr(), src, srcSize, - ); + ) } else { let blockCompressor_0 = ZSTD_selectBlockCompressor( (*zc).appliedParams.cParams.strategy, @@ -5399,14 +5365,15 @@ unsafe fn ZSTD_buildSeqStore( dictMode, ); ms.ldmSeqStore = core::ptr::null(); - lastLLSize = blockCompressor_0.unwrap_unchecked()( + blockCompressor_0.unwrap_unchecked()( ms, &mut (*zc).seqStore, ((*(*zc).blockState.nextCBlock).rep).as_mut_ptr(), src, srcSize, - ); - } + ) + }; + let lastLiterals = (src as *const u8) .add(srcSize) .offset(-(lastLLSize as isize)); @@ -5430,7 +5397,6 @@ unsafe fn ZSTD_copyBlockSequences( let nbOutSequences = nbInSequences.wrapping_add(1); let mut nbOutLiterals = 0 as size_t; let mut repcodes = repcodes_s { rep: [0; 3] }; - let mut i: size_t = 0; if nbOutSequences > ((*seqCollector).maxSequences).wrapping_sub((*seqCollector).seqIndex) { return Error::dstSize_tooSmall.to_error_code(); } @@ -5439,9 +5405,8 @@ unsafe fn ZSTD_copyBlockSequences( prevRepcodes as *const core::ffi::c_void, size_of::(), ); - i = 0; + let mut i: size_t = 0; while i < nbInSequences { - let mut rawOffset: u32 = 0; (*outSeqs.add(i)).litLength = (*inSeqs.add(i)).litLength as core::ffi::c_uint; (*outSeqs.add(i)).matchLength = ((*inSeqs.add(i)).mlBase as core::ffi::c_int + MINMATCH) as core::ffi::c_uint; @@ -5455,21 +5420,22 @@ unsafe fn ZSTD_copyBlockSequences( *fresh5 = (*fresh5).wrapping_add(0x10000 as core::ffi::c_int as core::ffi::c_uint); } } - if 1 <= (*inSeqs.add(i)).offBase && (*inSeqs.add(i)).offBase <= ZSTD_REP_NUM as u32 { - let repcode = (*inSeqs.add(i)).offBase; - (*outSeqs.add(i)).rep = repcode; - if (*outSeqs.add(i)).litLength != 0 { - rawOffset = *(repcodes.rep) - .as_mut_ptr() - .offset(repcode.wrapping_sub(1) as isize); - } else if repcode == 3 { - rawOffset = (*(repcodes.rep).as_mut_ptr()).wrapping_sub(1); + let rawOffset = + if 1 <= (*inSeqs.add(i)).offBase && (*inSeqs.add(i)).offBase <= ZSTD_REP_NUM as u32 { + let repcode = (*inSeqs.add(i)).offBase; + (*outSeqs.add(i)).rep = repcode; + if (*outSeqs.add(i)).litLength != 0 { + *(repcodes.rep) + .as_mut_ptr() + .offset(repcode.wrapping_sub(1) as isize) + } else if repcode == 3 { + (*(repcodes.rep).as_mut_ptr()).wrapping_sub(1) + } else { + *(repcodes.rep).as_mut_ptr().offset(repcode as isize) + } } else { - rawOffset = *(repcodes.rep).as_mut_ptr().offset(repcode as isize); - } - } else { - rawOffset = ((*inSeqs.add(i)).offBase).wrapping_sub(ZSTD_REP_NUM as u32); - } + ((*inSeqs.add(i)).offBase).wrapping_sub(ZSTD_REP_NUM as u32) + }; (*outSeqs.add(i)).offset = rawOffset; ZSTD_updateRep( (repcodes.rep).as_mut_ptr(), @@ -5501,7 +5467,6 @@ pub unsafe extern "C" fn ZSTD_generateSequences( srcSize: size_t, ) -> size_t { let dstCapacity = ZSTD_compressBound(srcSize); - let mut dst = core::ptr::null_mut::(); let mut seqCollector = SeqCollector { collectSequences: 0, seqStart: core::ptr::null_mut::(), @@ -5528,7 +5493,7 @@ pub unsafe extern "C" fn ZSTD_generateSequences( if nbWorkers != 0 { return Error::parameter_unsupported.to_error_code(); } - dst = ZSTD_customMalloc(dstCapacity, ZSTD_customMem::default()); + let dst = ZSTD_customMalloc(dstCapacity, ZSTD_customMem::default()); if dst.is_null() { return Error::memory_allocation.to_error_code(); } @@ -5574,7 +5539,6 @@ unsafe fn ZSTD_isRLE(src: *const u8, length: size_t) -> core::ffi::c_int { let unrollSize = size_of::().wrapping_mul(4); let unrollMask = unrollSize.wrapping_sub(1); let prefixLength = length & unrollMask; - let mut i: size_t = 0; if length == 1 { return 1; } @@ -5583,10 +5547,9 @@ unsafe fn ZSTD_isRLE(src: *const u8, length: size_t) -> core::ffi::c_int { { return 0; } - i = prefixLength; + let mut i = prefixLength; while i != length { let mut u: size_t = 0; - u = 0; while u < unrollSize { if MEM_readST(ip.add(i).add(u) as *const core::ffi::c_void) != valueST { return 0; @@ -5795,15 +5758,7 @@ unsafe fn ZSTD_buildBlockEntropyStats_sequences( ((if 35 > 52 { 35 as size_t } else { 52 }) + 1) .wrapping_mul(size_of::()), ); - let mut stats = ZSTD_symbolEncodingTypeStats_t { - LLtype: 0, - Offtype: 0, - MLtype: 0, - size: 0, - lastCountSize: 0, - longOffsets: 0, - }; - stats = if nbSeq != 0 { + let stats = if nbSeq != 0 { ZSTD_buildSequencesStatistics( seqStorePtr, nbSeq, @@ -6119,7 +6074,6 @@ unsafe fn ZSTD_countSeqStoreLiteralsBytes(seqStore: *const SeqStore_t) -> size_t let mut literalsBytes = 0 as size_t; let nbSeqs = ((*seqStore).sequences).offset_from((*seqStore).sequencesStart) as size_t; let mut i: size_t = 0; - i = 0; while i < nbSeqs { let seq = *((*seqStore).sequencesStart).add(i); literalsBytes = literalsBytes.wrapping_add(seq.litLength as size_t); @@ -6136,7 +6090,6 @@ unsafe fn ZSTD_countSeqStoreMatchBytes(seqStore: *const SeqStore_t) -> size_t { let mut matchBytes = 0 as size_t; let nbSeqs = ((*seqStore).sequences).offset_from((*seqStore).sequencesStart) as size_t; let mut i: size_t = 0; - i = 0; while i < nbSeqs { let seq = *((*seqStore).sequencesStart).add(i); matchBytes = matchBytes.wrapping_add((seq.mlBase as core::ffi::c_int + MINMATCH) as size_t); @@ -6242,8 +6195,6 @@ unsafe fn ZSTD_compressSeqStore_singleBlock( let rleMaxLength = 25; let op = dst as *mut u8; let ip = src as *const u8; - let mut cSize: size_t = 0; - let mut cSeqsSize: size_t = 0; let dRepOriginal = *dRep; if isPartition != 0 { ZSTD_seqStore_resolveOffCodes( @@ -6257,7 +6208,7 @@ unsafe fn ZSTD_compressSeqStore_singleBlock( if dstCapacity < ZSTD_blockHeaderSize { return Error::dstSize_tooSmall.to_error_code(); } - cSeqsSize = ZSTD_entropyCompressSeqStore( + let mut cSeqsSize = ZSTD_entropyCompressSeqStore( seqStore, &(*(*zc).blockState.prevCBlock).entropy, &mut (*(*zc).blockState.nextCBlock).entropy, @@ -6291,37 +6242,37 @@ unsafe fn ZSTD_compressSeqStore_singleBlock( ZSTD_blockState_confirmRepcodesAndEntropyTables(&mut (*zc).blockState); return 0; } - if cSeqsSize == 0 { - cSize = ZSTD_noCompressBlock( + let cSize = if cSeqsSize == 0 { + let cSize = ZSTD_noCompressBlock( op as *mut core::ffi::c_void, dstCapacity, ip as *const core::ffi::c_void, srcSize, lastBlock, ); - let err_code_1 = cSize; - if ERR_isError(err_code_1) { - return err_code_1; + if ERR_isError(cSize) { + return cSize; } *dRep = dRepOriginal; + cSize } else if cSeqsSize == 1 { - cSize = ZSTD_rleCompressBlock( + let cSize = ZSTD_rleCompressBlock( op as *mut core::ffi::c_void, dstCapacity, *ip, srcSize, lastBlock, ); - let err_code_2 = cSize; - if ERR_isError(err_code_2) { - return err_code_2; + if ERR_isError(cSize) { + return cSize; } *dRep = dRepOriginal; + cSize } else { ZSTD_blockState_confirmRepcodesAndEntropyTables(&mut (*zc).blockState); writeBlockHeader(op as *mut core::ffi::c_void, cSeqsSize, srcSize, lastBlock); - cSize = ZSTD_blockHeaderSize.wrapping_add(cSeqsSize); - } + ZSTD_blockHeaderSize.wrapping_add(cSeqsSize) + }; if (*(*zc).blockState.prevCBlock) .entropy .fse @@ -6346,9 +6297,6 @@ unsafe fn ZSTD_deriveBlockSplitsHelper( let fullSeqStoreChunk: &mut SeqStore_t = &mut (*zc).blockSplitCtx.fullSeqStoreChunk; let firstHalfSeqStore: &mut SeqStore_t = &mut (*zc).blockSplitCtx.firstHalfSeqStore; let secondHalfSeqStore: &mut SeqStore_t = &mut (*zc).blockSplitCtx.secondHalfSeqStore; - let mut estimatedOriginalSize: size_t = 0; - let mut estimatedFirstHalfSize: size_t = 0; - let mut estimatedSecondHalfSize: size_t = 0; let midIdx = startIdx.wrapping_add(endIdx) / 2; if endIdx.wrapping_sub(startIdx) < MIN_SEQUENCES_BLOCK_SPLITTING as size_t || (*splits).idx >= ZSTD_MAX_NB_BLOCK_SPLITS as size_t @@ -6358,11 +6306,11 @@ unsafe fn ZSTD_deriveBlockSplitsHelper( ZSTD_deriveSeqStoreChunk(fullSeqStoreChunk, origSeqStore, startIdx, endIdx); ZSTD_deriveSeqStoreChunk(firstHalfSeqStore, origSeqStore, startIdx, midIdx); ZSTD_deriveSeqStoreChunk(secondHalfSeqStore, origSeqStore, midIdx, endIdx); - estimatedOriginalSize = + let estimatedOriginalSize = ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(fullSeqStoreChunk, zc); - estimatedFirstHalfSize = + let estimatedFirstHalfSize = ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(firstHalfSeqStore, zc); - estimatedSecondHalfSize = + let estimatedSecondHalfSize = ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(secondHalfSeqStore, zc); if ERR_isError(estimatedOriginalSize) || ERR_isError(estimatedFirstHalfSize) @@ -6403,7 +6351,6 @@ unsafe fn ZSTD_compressBlock_splitBlock_internal( let mut cSize = 0 as size_t; let mut ip = src as *const u8; let mut op = dst as *mut u8; - let mut i = 0; let mut srcBytesTotal = 0 as size_t; let partitions = ((*zc).blockSplitCtx.partitions).as_mut_ptr(); let nextSeqStore: &mut SeqStore_t = &mut (*zc).blockSplitCtx.nextSeqStore; @@ -6446,9 +6393,8 @@ unsafe fn ZSTD_compressBlock_splitBlock_internal( return cSizeSingleBlock; } ZSTD_deriveSeqStoreChunk(currSeqStore, &(*zc).seqStore, 0, *partitions as size_t); - i = 0; + let mut i = 0; while i <= numSplits { - let mut cSizeChunk: size_t = 0; let lastPartition = (i == numSplits) as core::ffi::c_int as u32; let mut lastBlockEntireSrc = 0; let mut srcBytes = (ZSTD_countSeqStoreLiteralsBytes(currSeqStore)) @@ -6465,7 +6411,7 @@ unsafe fn ZSTD_compressBlock_splitBlock_internal( *partitions.add(i.wrapping_add(1)) as size_t, ); } - cSizeChunk = ZSTD_compressSeqStore_singleBlock( + let cSizeChunk = ZSTD_compressSeqStore_singleBlock( zc, currSeqStore, &mut dRep, @@ -6503,8 +6449,6 @@ unsafe fn ZSTD_compressBlock_splitBlock( srcSize: size_t, lastBlock: u32, ) -> size_t { - let mut nbSeq: u32 = 0; - let mut cSize: size_t = 0; let bss = ZSTD_buildSeqStore(zc, src, srcSize); let err_code = bss; if ERR_isError(err_code) { @@ -6525,16 +6469,17 @@ unsafe fn ZSTD_compressBlock_splitBlock( if (*zc).seqCollector.collectSequences != 0 { return Error::sequenceProducer_failed.to_error_code(); } - cSize = ZSTD_noCompressBlock(dst, dstCapacity, src, srcSize, lastBlock); + let cSize = ZSTD_noCompressBlock(dst, dstCapacity, src, srcSize, lastBlock); let err_code_0 = cSize; if ERR_isError(err_code_0) { return err_code_0; } return cSize; } - nbSeq = ((*zc).seqStore.sequences).offset_from((*zc).seqStore.sequencesStart) + + let nbSeq = ((*zc).seqStore.sequences).offset_from((*zc).seqStore.sequencesStart) as core::ffi::c_long as u32; - cSize = ZSTD_compressBlock_splitBlock_internal( + let cSize = ZSTD_compressBlock_splitBlock_internal( zc, dst, dstCapacity, @@ -6558,7 +6503,7 @@ unsafe fn ZSTD_compressBlock_internal( frame: u32, ) -> size_t { let rleMaxLength = 25; - let mut cSize: size_t = 0; + let mut cSize: size_t; let ip = src as *const u8; let op = dst as *mut u8; let bss = ZSTD_buildSeqStore(zc, src, srcSize); @@ -6667,13 +6612,12 @@ unsafe fn ZSTD_compressBlock_targetCBlockSize( srcSize: size_t, lastBlock: u32, ) -> size_t { - let mut cSize = 0; let bss = ZSTD_buildSeqStore(zc, src, srcSize); let err_code = bss; if ERR_isError(err_code) { return err_code; } - cSize = ZSTD_compressBlock_targetCBlockSize_body( + let cSize = ZSTD_compressBlock_targetCBlockSize_body( zc, dst, dstCapacity, @@ -6823,7 +6767,7 @@ unsafe fn ZSTD_compress_frameChunk( if ms.nextToUpdate < ms.window.lowLimit { ms.nextToUpdate = ms.window.lowLimit; } - let mut cSize: size_t = 0; + let mut cSize: size_t; if ZSTD_useTargetCBlockSize(&(*cctx).appliedParams) != 0 { cSize = ZSTD_compressBlock_targetCBlockSize( cctx, @@ -7252,7 +7196,6 @@ unsafe fn ZSTD_loadDictionaryContent( }); if srcSize > maxDictSize_0 as size_t { ip = iend.offset(-(maxDictSize_0 as isize)); - src = ip as *const core::ffi::c_void; srcSize = maxDictSize_0 as size_t; } ms.nextToUpdate = ip.offset_from(ms.window.base) as core::ffi::c_long as u32; @@ -7310,7 +7253,6 @@ unsafe fn ZSTD_dictNCountRepeat( if dictMaxSymbolValue < maxSymbolValue { return FSE_repeat_check; } - s = 0; while s <= maxSymbolValue { if *normalizedCounter.offset(s as isize) as core::ffi::c_int == 0 { return FSE_repeat_check; @@ -7453,7 +7395,6 @@ pub unsafe fn ZSTD_loadCEntropy( if offcodeMax < 31 { offcodeMax } else { 31 }, ); let mut u: u32 = 0; - u = 0; while u < 3 { if *((*bs).rep).as_mut_ptr().offset(u as isize) == 0 { return Error::dictionary_corrupted.to_error_code(); @@ -7478,14 +7419,12 @@ unsafe fn ZSTD_loadZstdDictionary( ) -> size_t { let mut dictPtr = dict as *const u8; let dictEnd = dictPtr.add(dictSize); - let mut dictID: size_t = 0; - let mut eSize: size_t = 0; - dictID = (if (*params).fParams.noDictIDFlag != 0 { + let dictID = (if (*params).fParams.noDictIDFlag != 0 { 0 } else { MEM_readLE32(dictPtr.add(4) as *const core::ffi::c_void) }) as size_t; - eSize = ZSTD_loadCEntropy(bs, workspace, dict, dictSize); + let eSize = ZSTD_loadCEntropy(bs, workspace, dict, dictSize); let err_code = eSize; if ERR_isError(err_code) { return err_code; @@ -7896,13 +7835,12 @@ pub unsafe extern "C" fn ZSTD_compressEnd_public( src: *const core::ffi::c_void, srcSize: size_t, ) -> size_t { - let mut endResult: size_t = 0; let cSize = ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1, 1); let err_code = cSize; if ERR_isError(err_code) { return err_code; } - endResult = ZSTD_writeEpilogue( + let endResult = ZSTD_writeEpilogue( cctx, (dst as *mut core::ffi::c_char).add(cSize) as *mut core::ffi::c_void, dstCapacity.wrapping_sub(cSize), @@ -8047,7 +7985,6 @@ pub unsafe extern "C" fn ZSTD_compress( srcSize: size_t, compressionLevel: core::ffi::c_int, ) -> size_t { - let mut result: size_t = 0; let mut ctxBody = ZSTD_CCtx_s { stage: ZSTDcs_created, cParamsChanged: 0, @@ -8460,7 +8397,7 @@ pub unsafe extern "C" fn ZSTD_compress( extSeqBufCapacity: 0, }; ZSTD_initCCtx(&mut ctxBody, ZSTD_customMem::default()); - result = ZSTD_compressCCtx( + let result = ZSTD_compressCCtx( &mut ctxBody, dst, dstCapacity, @@ -8725,26 +8662,19 @@ pub unsafe extern "C" fn ZSTD_createCDict_advanced2( customMem: ZSTD_customMem, ) -> *mut ZSTD_CDict { let mut cctxParams = *originalCctxParams; - let mut cParams = ZSTD_compressionParameters { - windowLog: 0, - chainLog: 0, - hashLog: 0, - searchLog: 0, - minMatch: 0, - targetLength: 0, - strategy: 0, - }; - if cctxParams.enableDedicatedDictSearch != 0 { - cParams = ZSTD_dedicatedDictSearch_getCParams(cctxParams.compressionLevel, dictSize); + let mut cParams = if cctxParams.enableDedicatedDictSearch != 0 { + let mut cParams = + ZSTD_dedicatedDictSearch_getCParams(cctxParams.compressionLevel, dictSize); ZSTD_overrideCParams(&mut cParams, &cctxParams.cParams); + cParams } else { - cParams = ZSTD_getCParamsFromCCtxParams( + ZSTD_getCParamsFromCCtxParams( &cctxParams, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_createCDict, - ); - } + ) + }; if ZSTD_dedicatedDictSearch_isSupported(&cParams) == 0 { cctxParams.enableDedicatedDictSearch = 0; cParams = ZSTD_getCParamsFromCCtxParams( @@ -8880,7 +8810,6 @@ pub unsafe extern "C" fn ZSTD_initStaticCDict( }) .wrapping_add(ZSTD_cwksp_alloc_size(HUF_WORKSPACE_SIZE)) .wrapping_add(matchStateSize); - let mut cdict = core::ptr::null_mut::(); let mut params = ZSTD_CCtx_params_s { format: Format::ZSTD_f_zstd1, cParams: ZSTD_compressionParameters { @@ -8949,7 +8878,7 @@ pub unsafe extern "C" fn ZSTD_initStaticCDict( isStatic: ZSTD_cwksp_dynamic_alloc, }; ZSTD_cwksp_init(&mut ws, workspace, workspaceSize, ZSTD_cwksp_static_alloc); - cdict = ZSTD_cwksp_reserve_object(&mut ws, size_of::()) as *mut ZSTD_CDict; + let cdict = ZSTD_cwksp_reserve_object(&mut ws, size_of::()) as *mut ZSTD_CDict; if cdict.is_null() { return core::ptr::null(); } @@ -9576,8 +9505,8 @@ unsafe fn ZSTD_compressStream_generic( as core::ffi::c_uint == ZSTD_bm_buffered as core::ffi::c_int as core::ffi::c_uint) as core::ffi::c_int; - let mut cDst = core::ptr::null_mut::(); - let mut cSize_0: size_t = 0; + let cDst; + let cSize_0: size_t; let mut oSize = oend.offset_from_unsigned(op); let iSize = if inputBuffered != 0 { ((*zcs).inBuffPos).wrapping_sub((*zcs).inToCompress) @@ -9976,7 +9905,7 @@ pub unsafe extern "C" fn ZSTD_compressStream2( return err_code_0; } if (*cctx).appliedParams.nbWorkers > 0 { - let mut flushMin: size_t = 0; + let mut flushMin: size_t; if (*cctx).cParamsChanged != 0 { ZSTDMT_updateCParams_whileCompressing((*cctx).mtctx, &(*cctx).requestedParams); (*cctx).cParamsChanged = 0; @@ -10153,14 +10082,13 @@ unsafe fn ZSTD_transferSequences_wBlockDelim( let mut ip = src as *const u8; let iend = ip.add(blockSize); let mut updatedRepcodes = repcodes_s { rep: [0; 3] }; - let mut dictSize: u32 = 0; - if !((*cctx).cdict).is_null() { - dictSize = (*(*cctx).cdict).dictContentSize as u32; + let dictSize = if !((*cctx).cdict).is_null() { + (*(*cctx).cdict).dictContentSize as u32 } else if !((*cctx).prefixDict.dict).is_null() { - dictSize = (*cctx).prefixDict.dictSize as u32; + (*cctx).prefixDict.dictSize as u32 } else { - dictSize = 0; - } + 0 + }; libc::memcpy( (updatedRepcodes.rep).as_mut_ptr() as *mut core::ffi::c_void, ((*(*cctx).blockState.prevCBlock).rep).as_mut_ptr() as *const core::ffi::c_void, @@ -10172,7 +10100,7 @@ unsafe fn ZSTD_transferSequences_wBlockDelim( { let litLength = (*inSeqs.offset(idx as isize)).litLength; let matchLength = (*inSeqs.offset(idx as isize)).matchLength; - let mut offBase: u32 = 0; + let offBase: u32; if externalRepSearch == ZSTD_ParamSwitch_e::ZSTD_ps_disable { offBase = ((*inSeqs.offset(idx as isize)).offset) .wrapping_add(ZSTD_REP_NUM as core::ffi::c_uint); @@ -10268,7 +10196,6 @@ unsafe fn ZSTD_transferSequences_noDelim( let mut idx = (*seqPos).idx; let mut startPosInSequence = (*seqPos).posInSequence; let mut endPosInSequence = ((*seqPos).posInSequence).wrapping_add(blockSize as u32); - let mut dictSize: size_t = 0; let istart = src as *const u8; let mut ip = istart; let mut iend = istart.add(blockSize); @@ -10279,13 +10206,13 @@ unsafe fn ZSTD_transferSequences_noDelim( /* TODO(embg) support fast parsing mode in noBlockDelim mode */ let _ = externalRepSearch; - if !((*cctx).cdict).is_null() { - dictSize = (*(*cctx).cdict).dictContentSize; + let dictSize = if !((*cctx).cdict).is_null() { + (*(*cctx).cdict).dictContentSize } else if !((*cctx).prefixDict.dict).is_null() { - dictSize = (*cctx).prefixDict.dictSize; + (*cctx).prefixDict.dictSize } else { - dictSize = 0; - } + 0 + }; libc::memcpy( (updatedRepcodes.rep).as_mut_ptr() as *mut core::ffi::c_void, ((*(*cctx).blockState.prevCBlock).rep).as_mut_ptr() as *const core::ffi::c_void, @@ -10296,7 +10223,6 @@ unsafe fn ZSTD_transferSequences_noDelim( let mut litLength = currSeq.litLength; let mut matchLength = currSeq.matchLength; let rawOffset = currSeq.offset; - let mut offBase: u32 = 0; if endPosInSequence >= (currSeq.litLength).wrapping_add(currSeq.matchLength) { if startPosInSequence >= litLength { startPosInSequence = startPosInSequence.wrapping_sub(litLength); @@ -10312,13 +10238,12 @@ unsafe fn ZSTD_transferSequences_noDelim( if endPosInSequence <= litLength { break; } - let mut firstHalfMatchLength: u32 = 0; litLength = if startPosInSequence >= litLength { 0 } else { litLength.wrapping_sub(startPosInSequence) }; - firstHalfMatchLength = endPosInSequence + let mut firstHalfMatchLength = endPosInSequence .wrapping_sub(startPosInSequence) .wrapping_sub(litLength); if matchLength as size_t > blockSize @@ -10345,7 +10270,7 @@ unsafe fn ZSTD_transferSequences_noDelim( } } let ll0 = (litLength == 0) as core::ffi::c_int as u32; - offBase = ZSTD_finalizeOffBase( + let offBase = ZSTD_finalizeOffBase( rawOffset, (updatedRepcodes.rep).as_mut_ptr() as *const u32, ll0, @@ -10517,8 +10442,8 @@ unsafe fn ZSTD_compressSequences_internal( cSize = cSize.wrapping_add(ZSTD_blockHeaderSize); } while remaining != 0 { - let mut compressedSeqsSize: size_t = 0; - let mut cBlockSize: size_t = 0; + let mut compressedSeqsSize: size_t; + let cBlockSize: size_t; let mut blockSize = determine_blockSize( (*cctx).appliedParams.blockDelimiters, (*cctx).blockSizeMax, @@ -10619,7 +10544,6 @@ unsafe fn ZSTD_compressSequences_internal( return err_code_4; } } else { - let mut cBlockHeader: u32 = 0; ZSTD_blockState_confirmRepcodesAndEntropyTables(&mut (*cctx).blockState); if (*(*cctx).blockState.prevCBlock) .entropy @@ -10632,7 +10556,7 @@ unsafe fn ZSTD_compressSequences_internal( .fse .offcode_repeatMode = FSE_repeat_check; } - cBlockHeader = lastBlock + let cBlockHeader = lastBlock .wrapping_add((bt_compressed as core::ffi::c_int as u32) << 1) .wrapping_add((compressedSeqsSize << 3) as u32); MEM_writeLE24(op as *mut core::ffi::c_void, cBlockHeader); @@ -10718,7 +10642,6 @@ pub unsafe fn convertSequences_noRepcodes( ) -> size_t { let mut longLen = 0; let mut n: size_t = 0; - n = 0; while n < nbSequences { (*dstSeqs.add(n)).offBase = ((*inSeqs.add(n)).offset).wrapping_add(ZSTD_REP_NUM as core::ffi::c_uint); @@ -10742,7 +10665,6 @@ pub unsafe fn ZSTD_convertBlockSequences( repcodeResolution: core::ffi::c_int, ) -> size_t { let mut updatedRepcodes = repcodes_s { rep: [0; 3] }; - let mut seqNb = 0; if nbSequences >= (*cctx).seqStore.maxNbSeq { return Error::externalSequences_invalid.to_error_code(); } @@ -10770,7 +10692,7 @@ pub unsafe fn ZSTD_convertBlockSequences( } } } else { - seqNb = 0; + let mut seqNb = 0; while seqNb < nbSequences.wrapping_sub(1) { let litLength = (*inSeqs.add(seqNb)).litLength; let matchLength = (*inSeqs.add(seqNb)).matchLength; @@ -10962,9 +10884,6 @@ unsafe fn ZSTD_compressSequencesAndLiterals_internal( cSize = cSize.wrapping_add(ZSTD_blockHeaderSize); } while nbSequences != 0 { - let mut compressedSeqsSize: size_t = 0; - let mut cBlockSize: size_t = 0; - let mut conversionStatus: size_t = 0; let block = ZSTD_get1BlockSummary(inSeqs, nbSequences); let lastBlock = (block.nbSequences == nbSequences) as core::ffi::c_int as u32; let err_code = block.nbSequences; @@ -10975,7 +10894,7 @@ unsafe fn ZSTD_compressSequencesAndLiterals_internal( return Error::externalSequences_invalid.to_error_code(); } ZSTD_resetSeqStore(&mut (*cctx).seqStore); - conversionStatus = + let conversionStatus = ZSTD_convertBlockSequences(cctx, inSeqs, block.nbSequences, repcodeResolution); let err_code_0 = conversionStatus; if ERR_isError(err_code_0) { @@ -10987,7 +10906,7 @@ unsafe fn ZSTD_compressSequencesAndLiterals_internal( if dstCapacity < ZSTD_blockHeaderSize { return Error::dstSize_tooSmall.to_error_code(); } - compressedSeqsSize = ZSTD_entropyCompressSeqStore_internal( + let mut compressedSeqsSize = ZSTD_entropyCompressSeqStore_internal( op.add(ZSTD_blockHeaderSize) as *mut core::ffi::c_void, dstCapacity.wrapping_sub(ZSTD_blockHeaderSize), literals, @@ -11010,10 +10929,10 @@ unsafe fn ZSTD_compressSequencesAndLiterals_internal( litSize = litSize.wrapping_sub(block.litSize); literals = (literals as *const core::ffi::c_char).add(block.litSize) as *const core::ffi::c_void; + let cBlockSize: size_t; if compressedSeqsSize == 0 { return Error::cannotProduce_uncompressedBlock.to_error_code(); } else { - let mut cBlockHeader: u32 = 0; ZSTD_blockState_confirmRepcodesAndEntropyTables(&mut (*cctx).blockState); if (*(*cctx).blockState.prevCBlock) .entropy @@ -11026,7 +10945,7 @@ unsafe fn ZSTD_compressSequencesAndLiterals_internal( .fse .offcode_repeatMode = FSE_repeat_check; } - cBlockHeader = lastBlock + let cBlockHeader = lastBlock .wrapping_add((bt_compressed as core::ffi::c_int as u32) << 1) .wrapping_add((compressedSeqsSize << 3) as u32); MEM_writeLE24(op as *mut core::ffi::c_void, cBlockHeader); @@ -11104,9 +11023,7 @@ pub unsafe extern "C" fn ZSTD_compressSequencesAndLiterals( if ERR_isError(err_code_0) { return err_code_0; } - cSize = cSize.wrapping_add(cBlocksSize); - dstCapacity = dstCapacity.wrapping_sub(cBlocksSize); - cSize + cSize.wrapping_add(cBlocksSize) } unsafe fn inBuffer_forEndFlush(zcs: *const ZSTD_CStream) -> ZSTD_inBuffer { let nullInput = { @@ -12285,16 +12202,11 @@ unsafe fn ZSTD_getCParams_internal( let tableID = ((rSize <= (256 * ((1) << 10)) as u64) as core::ffi::c_int + (rSize <= (128 * ((1) << 10)) as u64) as core::ffi::c_int + (rSize <= (16 * ((1) << 10)) as u64) as core::ffi::c_int) as u32; - let mut row: core::ffi::c_int = 0; - if compressionLevel == 0 { - row = ZSTD_CLEVEL_DEFAULT; - } else if compressionLevel < 0 { - row = 0; - } else if compressionLevel > ZSTD_MAX_CLEVEL { - row = ZSTD_MAX_CLEVEL; + let row = if compressionLevel == 0 { + ZSTD_CLEVEL_DEFAULT } else { - row = compressionLevel; - } + compressionLevel.clamp(0, ZSTD_MAX_CLEVEL) + }; let mut cp = *(*ZSTD_defaultCParameters.as_ptr().offset(tableID as isize)) .as_ptr() .offset(row as isize); diff --git a/lib/compress/zstd_compress_literals.rs b/lib/compress/zstd_compress_literals.rs index 16d008bd..aa1d471c 100644 --- a/lib/compress/zstd_compress_literals.rs +++ b/lib/compress/zstd_compress_literals.rs @@ -86,8 +86,7 @@ pub unsafe fn ZSTD_noCompressLiterals( } unsafe fn allBytesIdentical(src: *const core::ffi::c_void, srcSize: size_t) -> bool { let b = *(src as *const u8); - let mut p: size_t = 0; - p = 1; + let mut p: size_t = 1; while p < srcSize { if *(src as *const u8).add(p) as core::ffi::c_int != b as core::ffi::c_int { return false; @@ -167,7 +166,6 @@ pub unsafe fn ZSTD_compressLiterals( let ostart = dst as *mut u8; let mut singleStream = (srcSize < 256) as core::ffi::c_int as u32; let mut hType = set_compressed; - let mut cLitSize: size_t = 0; libc::memcpy( nextHuf as *mut core::ffi::c_void, prevHuf as *const core::ffi::c_void, @@ -204,13 +202,12 @@ pub unsafe fn ZSTD_compressLiterals( } else { 0 }); - let mut huf_compress: huf_compress_f = None; if repeat as core::ffi::c_uint == HUF_repeat_valid as core::ffi::c_int as core::ffi::c_uint && lhSize == 3 { singleStream = 1; } - huf_compress = if singleStream != 0 { + let huf_compress = if singleStream != 0 { Some( HUF_compress1X_repeat as unsafe extern "C" fn( @@ -245,7 +242,7 @@ pub unsafe fn ZSTD_compressLiterals( ) -> size_t, ) }; - cLitSize = huf_compress.unwrap_unchecked()( + let cLitSize = huf_compress.unwrap_unchecked()( ostart.add(lhSize) as *mut core::ffi::c_void, dstCapacity.wrapping_sub(lhSize), src, diff --git a/lib/compress/zstd_compress_sequences.rs b/lib/compress/zstd_compress_sequences.rs index cc2f68ee..a42483d3 100644 --- a/lib/compress/zstd_compress_sequences.rs +++ b/lib/compress/zstd_compress_sequences.rs @@ -91,7 +91,6 @@ unsafe fn ZSTD_entropyCost( ) -> size_t { let mut cost = 0 as core::ffi::c_uint; let mut s: core::ffi::c_uint = 0; - s = 0; while s <= max { let mut norm = ((256 as core::ffi::c_uint).wrapping_mul(*count.offset(s as isize)) as size_t @@ -114,7 +113,6 @@ pub unsafe fn ZSTD_fseBitCost( ) -> size_t { let kAccuracyLog = 8; let mut cost = 0 as size_t; - let mut s: core::ffi::c_uint = 0; let mut cstate = FSE_CState_t { value: 0, stateTable: core::ptr::null::(), @@ -125,7 +123,7 @@ pub unsafe fn ZSTD_fseBitCost( if ZSTD_getFSEMaxSymbolValue(ctable) < max { return Error::GENERIC.to_error_code(); } - s = 0; + let mut s: core::ffi::c_uint = 0; while s <= max { let tableLog = cstate.stateLog; let badCost = tableLog.wrapping_add(1) << kAccuracyLog; @@ -149,7 +147,6 @@ pub unsafe fn ZSTD_crossEntropyCost( let shift = (8 as core::ffi::c_uint).wrapping_sub(accuracyLog); let mut cost = 0 as size_t; let mut s: core::ffi::c_uint = 0; - s = 0; while s <= max { let normAcc = if *norm.offset(s as isize) as core::ffi::c_int != -(1) { *norm.offset(s as isize) as core::ffi::c_uint @@ -444,8 +441,7 @@ unsafe fn ZSTD_encodeSequences_body( ); } BIT_flushBits(&mut blockStream); - let mut n: size_t = 0; - n = nbSeq.wrapping_sub(2); + let mut n = nbSeq.wrapping_sub(2); while n < nbSeq { let llCode = *llCodeTable.add(n); let ofCode = *ofCodeTable.add(n); diff --git a/lib/compress/zstd_compress_superblock.rs b/lib/compress/zstd_compress_superblock.rs index 65e5f71d..8590d238 100644 --- a/lib/compress/zstd_compress_superblock.rs +++ b/lib/compress/zstd_compress_superblock.rs @@ -428,7 +428,6 @@ unsafe fn ZSTD_seqDecompressedSize( let mut matchLengthSum = 0 as size_t; let mut litLengthSum = 0 as size_t; let mut n: size_t = 0; - n = 0; while n < nbSeqs { let seqLen = ZSTD_getSequenceLength(seqStore, sequences.add(n)); litLengthSum = litLengthSum.wrapping_add(seqLen.litLength as size_t); @@ -468,7 +467,6 @@ unsafe fn ZSTD_compressSubBlock_sequences( let ostart = dst as *mut u8; let oend = ostart.add(dstCapacity); let mut op = ostart; - let mut seqHead = core::ptr::null_mut::(); *entropyWritten = 0; if (oend.offset_from(op) as core::ffi::c_long) < (3 + 1) as core::ffi::c_long { return Error::dstSize_tooSmall.to_error_code(); @@ -494,7 +492,7 @@ unsafe fn ZSTD_compressSubBlock_sequences( } let fresh1 = op; op = op.add(1); - seqHead = fresh1; + let seqHead = fresh1; if writeEntropy != 0 { let LLtype = (*fseMetadata).llType; let Offtype = (*fseMetadata).ofType; @@ -852,7 +850,6 @@ unsafe fn countLiterals( ) -> size_t { let mut n: size_t = 0; let mut total = 0 as size_t; - n = 0; while n < seqCount { total = total.wrapping_add((ZSTD_getSequenceLength(seqStore, sp.add(n))).litLength as size_t); @@ -869,18 +866,16 @@ unsafe fn sizeBlockSequences( avgSeqCost: size_t, firstSubBlock: core::ffi::c_int, ) -> size_t { - let mut n: size_t = 0; let mut budget = 0 as size_t; - let mut inSize = 0; let headerSize = firstSubBlock as size_t * 120 * BYTESCALE as size_t; budget = budget.wrapping_add(headerSize); budget = budget.wrapping_add(((*sp).litLength as size_t * avgLitCost).wrapping_add(avgSeqCost)); if budget > targetBudget { return 1; } - inSize = ((*sp).litLength as core::ffi::c_int + ((*sp).mlBase as core::ffi::c_int + MINMATCH)) - as size_t; - n = 1; + let mut inSize = ((*sp).litLength as core::ffi::c_int + + ((*sp).mlBase as core::ffi::c_int + MINMATCH)) as size_t; + let mut n: size_t = 1; while n < nbSeqs { let currentCost = ((*sp.add(n)).litLength as size_t * avgLitCost).wrapping_add(avgSeqCost); budget = budget.wrapping_add(currentCost); @@ -965,14 +960,12 @@ unsafe fn ZSTD_compressSubBlock_multi( } else { 1 }; - let mut n: size_t = 0; - let mut avgBlockBudget: size_t = 0; let mut blockBudgetSupp = 0; - avgBlockBudget = ebs.estBlockSize * BYTESCALE as size_t / nbSubBlocks; + let avgBlockBudget = ebs.estBlockSize * BYTESCALE as size_t / nbSubBlocks; if ebs.estBlockSize > srcSize { return 0; } - n = 0; + let mut n: size_t = 0; while n < nbSubBlocks.wrapping_sub(1) { let seqCount = sizeBlockSequences( sp, @@ -1063,11 +1056,7 @@ unsafe fn ZSTD_compressSubBlock_multi( } if cSize_0 > 0 && cSize_0 < decompressedSize_0 { ip = ip.add(decompressedSize_0); - lp = lp.add(litSize_0); op = op.add(cSize_0); - llCodePtr = llCodePtr.add(seqCount_0); - mlCodePtr = mlCodePtr.add(seqCount_0); - ofCodePtr = ofCodePtr.add(seqCount_0); if litEntropyWritten_0 != 0 { writeLitEntropy = 0; } @@ -1102,14 +1091,13 @@ unsafe fn ZSTD_compressSubBlock_multi( } op = op.add(cSize_1); if sp < send { - let mut seq = core::ptr::null::(); let mut rep = repcodes_s { rep: [0; 3] }; libc::memcpy( &mut rep as *mut Repcodes_t as *mut core::ffi::c_void, ((*prevCBlock).rep).as_ptr() as *const core::ffi::c_void, size_of::() as core::ffi::c_ulong as libc::size_t, ); - seq = sstart; + let mut seq = sstart; while seq < sp { ZSTD_updateRep( (rep.rep).as_mut_ptr(), diff --git a/lib/compress/zstd_double_fast.rs b/lib/compress/zstd_double_fast.rs index 92b76a1c..935b2015 100644 --- a/lib/compress/zstd_double_fast.rs +++ b/lib/compress/zstd_double_fast.rs @@ -99,7 +99,6 @@ unsafe fn ZSTD_fillDoubleHashTableForCDict( while ip.offset(fastHashFillStep as isize).sub(1) <= iend { let curr = ip.offset_from(base) as core::ffi::c_long as u32; let mut i: u32 = 0; - i = 0; while i < fastHashFillStep { let smHashAndTag = ZSTD_hashPtr( ip.offset(i as isize) as *const core::ffi::c_void, @@ -141,7 +140,6 @@ unsafe fn ZSTD_fillDoubleHashTableForCCtx( while ip.offset(fastHashFillStep as isize).sub(1) <= iend { let curr = ip.offset_from(base) as core::ffi::c_long as u32; let mut i: u32 = 0; - i = 0; while i < fastHashFillStep { let smHash = ZSTD_hashPtr( ip.offset(i as isize) as *const core::ffi::c_void, @@ -204,20 +202,11 @@ unsafe fn ZSTD_compressBlock_doubleFast_noDict_generic( let mut offsetSaved2 = 0; let mut mLength: size_t = 0; let mut offset: u32 = 0; - let mut curr: u32 = 0; let kStepIncr = ((1) << kSearchStrength) as size_t; - let mut nextStep = core::ptr::null::(); - let mut step: size_t = 0; - let mut hl0: size_t = 0; let mut hl1: size_t = 0; - let mut idxl0: u32 = 0; let mut idxl1: u32 = 0; - let mut matchl0 = core::ptr::null::(); - let mut matchs0 = core::ptr::null::(); let mut matchl1 = core::ptr::null::(); - let mut matchs0_safe = core::ptr::null::(); let mut ip = istart; - let mut ip1 = core::ptr::null::(); let dummy: [u8; 10] = [ 0x12 as core::ffi::c_int as u8, 0x34 as core::ffi::c_int as u8, @@ -247,13 +236,15 @@ unsafe fn ZSTD_compressBlock_doubleFast_noDict_generic( loop { 's_428: { let mut current_block_83: u64; - step = 1; - nextStep = ip.add(kStepIncr); - ip1 = ip.add(step); + let mut step = 1; + let mut nextStep = ip.add(kStepIncr); + let mut ip1 = ip.add(step); if ip1 <= ilimit { - hl0 = ZSTD_hashPtr(ip as *const core::ffi::c_void, hBitsL, 8); - idxl0 = *hashLong.add(hl0); - matchl0 = base.offset(idxl0 as isize); + let mut hl0 = ZSTD_hashPtr(ip as *const core::ffi::c_void, hBitsL, 8); + let mut idxl0 = *hashLong.add(hl0); + let mut matchl0 = base.offset(idxl0 as isize); + let mut matchs0: *const u8; + let mut curr: u32; loop { let hs0 = ZSTD_hashPtr(ip as *const core::ffi::c_void, hBitsS, mls); let idxs0 = *hashSmall.add(hs0); @@ -316,7 +307,7 @@ unsafe fn ZSTD_compressBlock_doubleFast_noDict_generic( } else { idxl1 = *hashLong.add(hl1); matchl1 = base.offset(idxl1 as isize); - matchs0_safe = { + let matchs0_safe = { core::hint::select_unpredictable( idxs0 >= prefixLowestIndex, matchs0, @@ -1055,7 +1046,7 @@ unsafe fn ZSTD_compressBlock_doubleFast_extDict_generic( base }; let repMatch = repBase.wrapping_offset(repIndex as isize); - let mut mLength: size_t = 0; + let mut mLength: size_t; let fresh4 = &mut (*hashLong.add(hLong)); *fresh4 = curr; *hashSmall.add(hSmall) = *fresh4; @@ -1101,11 +1092,10 @@ unsafe fn ZSTD_compressBlock_doubleFast_extDict_generic( } else { prefixStart }; - let mut offset: u32 = 0; mLength = (ZSTD_count_2segments(ip.add(8), matchLong.add(8), iend, matchEnd, prefixStart)) .wrapping_add(8); - offset = curr.wrapping_sub(matchLongIndex); + let offset = curr.wrapping_sub(matchLongIndex); while (ip > anchor) as core::ffi::c_int & (matchLong > lowMatchPtr) as core::ffi::c_int != 0 && *ip.sub(1) as core::ffi::c_int == *matchLong.sub(1) as core::ffi::c_int @@ -1136,7 +1126,7 @@ unsafe fn ZSTD_compressBlock_doubleFast_extDict_generic( base }; let mut match3 = match3Base.offset(matchIndex3 as isize); - let mut offset_0: u32 = 0; + let offset_0: u32; *hashLong.add(h3) = curr.wrapping_add(1); if matchIndex3 > dictStartIndex && MEM_read64(match3 as *const core::ffi::c_void) diff --git a/lib/compress/zstd_fast.rs b/lib/compress/zstd_fast.rs index 083690a6..bb48e1f7 100644 --- a/lib/compress/zstd_fast.rs +++ b/lib/compress/zstd_fast.rs @@ -100,8 +100,7 @@ unsafe fn ZSTD_fillHashTableForCDict( let hashAndTag = ZSTD_hashPtr(ip as *const core::ffi::c_void, hBits, mls); ZSTD_writeTaggedIndex(hashTable, hashAndTag, curr); if dtlm as core::ffi::c_uint != ZSTD_dtlm_fast as core::ffi::c_int as core::ffi::c_uint { - let mut p: u32 = 0; - p = 1; + let mut p: u32 = 1; while p < fastHashFillStep { let hashAndTag_0 = ZSTD_hashPtr( ip.offset(p as isize) as *const core::ffi::c_void, @@ -135,8 +134,7 @@ unsafe fn ZSTD_fillHashTableForCCtx( let hash0 = ZSTD_hashPtr(ip as *const core::ffi::c_void, hBits, mls); *hashTable.add(hash0) = curr; if dtlm as core::ffi::c_uint != ZSTD_dtlm_fast as core::ffi::c_int as core::ffi::c_uint { - let mut p: u32 = 0; - p = 1; + let mut p: u32 = 1; while p < fastHashFillStep { let hash = ZSTD_hashPtr( ip.offset(p as isize) as *const core::ffi::c_void, @@ -204,12 +202,11 @@ unsafe fn ZSTD_match4Found_branch( matchIdx: u32, idxLowLimit: u32, ) -> core::ffi::c_int { - let mut mval: u32 = 0; - if matchIdx >= idxLowLimit { - mval = MEM_read32(matchAddress as *const core::ffi::c_void); + let mval = if matchIdx >= idxLowLimit { + MEM_read32(matchAddress as *const core::ffi::c_void) } else { - mval = MEM_read32(currentPtr as *const core::ffi::c_void) ^ 1; - } + MEM_read32(currentPtr as *const core::ffi::c_void) ^ 1 + }; (MEM_read32(currentPtr as *const core::ffi::c_void) == mval) as core::ffi::c_int } #[inline(always)] @@ -238,22 +235,13 @@ unsafe fn ZSTD_compressBlock_fast_noDict_generic( let ilimit = iend.offset(-(HASH_READ_SIZE as isize)); let mut anchor = istart; let mut ip0 = istart; - let mut ip1 = core::ptr::null::(); - let mut ip2 = core::ptr::null::(); - let mut ip3 = core::ptr::null::(); - let mut current0: u32 = 0; let mut rep_offset1 = *rep; let mut rep_offset2 = *rep.add(1); let mut offsetSaved1 = 0; let mut offsetSaved2 = 0; - let mut hash0: size_t = 0; - let mut hash1: size_t = 0; - let mut matchIdx: u32 = 0; let mut offcode: u32 = 0; let mut match0 = core::ptr::null::(); let mut mLength: size_t = 0; - let mut step: size_t = 0; - let mut nextStep = core::ptr::null::(); let kStepIncr = ((1) << (kSearchStrength - 1)) as size_t; let matchFound: ZSTD_match4Found = if useCmov != 0 { Some(ZSTD_match4Found_cmov as unsafe fn(*const u8, *const u8, u32, u32) -> core::ffi::c_int) @@ -276,17 +264,18 @@ unsafe fn ZSTD_compressBlock_fast_noDict_generic( rep_offset1 = 0; } '__start: loop { - step = stepSize; - nextStep = ip0.add(kStepIncr); - ip1 = ip0.add(1); - ip2 = ip0.add(step); - ip3 = ip2.add(1); + let mut step = stepSize; + let mut nextStep = ip0.add(kStepIncr); + let mut ip1 = ip0.add(1); + let mut ip2 = ip0.add(step); + let mut ip3 = ip2.add(1); if ip3 >= ilimit { break; } - hash0 = ZSTD_hashPtr(ip0 as *const core::ffi::c_void, hlog, mls); - hash1 = ZSTD_hashPtr(ip1 as *const core::ffi::c_void, hlog, mls); - matchIdx = *hashTable.add(hash0); + let mut hash0 = ZSTD_hashPtr(ip0 as *const core::ffi::c_void, hlog, mls); + let mut hash1 = ZSTD_hashPtr(ip1 as *const core::ffi::c_void, hlog, mls); + let mut matchIdx = *hashTable.add(hash0); + let mut current0: u32; loop { let rval = MEM_read32(ip2.offset(-(rep_offset1 as isize)) as *const core::ffi::c_void); current0 = ip0.offset_from(base) as core::ffi::c_long as u32; @@ -596,7 +585,7 @@ unsafe fn ZSTD_compressBlock_fast_dictMatchState_generic( } ip0 = ip0.offset((dictAndPrefixLength == 0) as core::ffi::c_int as isize); 's_135: while ip1 <= ilimit { - let mut mLength: size_t = 0; + let mut mLength: size_t; let mut hash0 = ZSTD_hashPtr(ip0 as *const core::ffi::c_void, hlog, mls); let dictHashAndTag0 = ZSTD_hashPtr(ip0 as *const core::ffi::c_void, dictHBits, mls); let mut dictMatchIndexAndTag = @@ -884,20 +873,10 @@ unsafe fn ZSTD_compressBlock_fast_extDict_generic( let mut offsetSaved1 = 0; let mut offsetSaved2 = 0; let mut ip0 = istart; - let mut ip1 = core::ptr::null::(); - let mut ip2 = core::ptr::null::(); - let mut ip3 = core::ptr::null::(); - let mut current0: u32 = 0; - let mut hash0: size_t = 0; - let mut hash1: size_t = 0; - let mut idx: u32 = 0; - let mut idxBase = core::ptr::null::(); let mut offcode: u32 = 0; let mut match0 = core::ptr::null::(); let mut mLength: size_t = 0; let mut matchEnd = core::ptr::null::(); - let mut step: size_t = 0; - let mut nextStep = core::ptr::null::(); let kStepIncr = ((1) << (kSearchStrength - 1)) as size_t; let _ = hasStep; /* not currently specialized on whether it's accelerated */ @@ -916,18 +895,19 @@ unsafe fn ZSTD_compressBlock_fast_extDict_generic( offset_1 = 0; } '__start: loop { - step = stepSize; - nextStep = ip0.add(kStepIncr); - ip1 = ip0.add(1); - ip2 = ip0.add(step); - ip3 = ip2.add(1); + let mut current0: u32; + let mut step = stepSize; + let mut nextStep = ip0.add(kStepIncr); + let mut ip1 = ip0.add(1); + let mut ip2 = ip0.add(step); + let mut ip3 = ip2.add(1); if ip3 >= ilimit { break; } - hash0 = ZSTD_hashPtr(ip0 as *const core::ffi::c_void, hlog, mls); - hash1 = ZSTD_hashPtr(ip1 as *const core::ffi::c_void, hlog, mls); - idx = *hashTable.add(hash0); - idxBase = if idx < prefixStartIndex { + let mut hash0 = ZSTD_hashPtr(ip0 as *const core::ffi::c_void, hlog, mls); + let mut hash1 = ZSTD_hashPtr(ip1 as *const core::ffi::c_void, hlog, mls); + let mut idx = *hashTable.add(hash0); + let mut idxBase = if idx < prefixStartIndex { dictBase } else { base @@ -940,15 +920,14 @@ unsafe fn ZSTD_compressBlock_fast_extDict_generic( } else { base }; - let mut rval: u32 = 0; - if (prefixStartIndex.wrapping_sub(repIndex) >= 4) as core::ffi::c_int + let rval = if (prefixStartIndex.wrapping_sub(repIndex) >= 4) as core::ffi::c_int & (offset_1 > 0) as core::ffi::c_int != 0 { - rval = MEM_read32(repBase.offset(repIndex as isize) as *const core::ffi::c_void); + MEM_read32(repBase.offset(repIndex as isize) as *const core::ffi::c_void) } else { - rval = MEM_read32(ip2 as *const core::ffi::c_void) ^ 1; - } + MEM_read32(ip2 as *const core::ffi::c_void) ^ 1 + }; current0 = ip0.offset_from(base) as core::ffi::c_long as u32; *hashTable.add(hash0) = current0; if MEM_read32(ip2 as *const core::ffi::c_void) == rval { diff --git a/lib/compress/zstd_lazy.rs b/lib/compress/zstd_lazy.rs index dccd6ddb..d0db761d 100644 --- a/lib/compress/zstd_lazy.rs +++ b/lib/compress/zstd_lazy.rs @@ -137,7 +137,6 @@ unsafe fn ZSTD_insertDUBT1( }; let dictEnd = dictBase.offset(dictLimit as isize); let prefixStart = base.offset(dictLimit as isize); - let mut match_0 = core::ptr::null::(); let mut smallerPtr = bt.offset((2 * (curr & btMask)) as isize); let mut largerPtr = smallerPtr.add(1); let mut matchIndex = *smallerPtr; @@ -156,6 +155,7 @@ unsafe fn ZSTD_insertDUBT1( } else { commonLengthLarger }; + let mut match_0: *const u8; if dictMode as core::ffi::c_uint != ZSTD_extDict as core::ffi::c_int as core::ffi::c_uint || (matchIndex as size_t).wrapping_add(matchLength) >= dictLimit as size_t || curr < dictLimit @@ -386,7 +386,7 @@ unsafe fn ZSTD_DUBT_findBestMatch( } else { commonLengthLarger }; - let mut match_0 = core::ptr::null::(); + let mut match_0: *const u8; if dictMode as core::ffi::c_uint != ZSTD_extDict as core::ffi::c_int as core::ffi::c_uint || (matchIndex as size_t).wrapping_add(matchLength) >= dictLimit as size_t { @@ -517,7 +517,6 @@ pub unsafe fn ZSTD_dedicatedDictSearch_lazy_loadDictionary( } else { idx }; - let mut hashIdx: u32 = 0; while idx < target { let h = ZSTD_hashPtr( base.offset(idx as isize) as *const core::ffi::c_void, @@ -532,12 +531,11 @@ pub unsafe fn ZSTD_dedicatedDictSearch_lazy_loadDictionary( idx = idx.wrapping_add(1); } let mut chainPos = 0u32; - hashIdx = 0; + let mut hashIdx: u32 = 0; while hashIdx < (1) << hashLog { let mut count: u32 = 0; let mut countBeyondMinChain = 0u32; let mut i = *tmpHashTable.offset(hashIdx as isize); - count = 0; while i >= tmpMinChain && count < cacheSize { if i < minChain { countBeyondMinChain = countBeyondMinChain.wrapping_add(1); @@ -582,7 +580,6 @@ pub unsafe fn ZSTD_dedicatedDictSearch_lazy_loadDictionary( let bucketIdx = hashIdx << ZSTD_LAZY_DDSS_BUCKET_LOG; let chainPackedPointer = *tmpHashTable.offset(hashIdx as isize); let mut i_0: u32 = 0; - i_0 = 0; while i_0 < cacheSize { *hashTable.offset(bucketIdx.wrapping_add(i_0) as isize) = 0; i_0 = i_0.wrapping_add(1); @@ -598,8 +595,7 @@ pub unsafe fn ZSTD_dedicatedDictSearch_lazy_loadDictionary( ms.cParams.minMatch, ) as u32) << ZSTD_LAZY_DDSS_BUCKET_LOG; - let mut i_1: u32 = 0; - i_1 = cacheSize.wrapping_sub(1); + let mut i_1 = cacheSize.wrapping_sub(1); while i_1 != 0 { *hashTable.offset(h_0.wrapping_add(i_1) as isize) = *hashTable.offset(h_0.wrapping_add(i_1).wrapping_sub(1) as isize); @@ -635,8 +631,6 @@ unsafe fn ZSTD_dedicatedDictSearch_lazy_search( bucketSize.wrapping_sub(1) }; let mut ddsAttempt: u32 = 0; - let mut matchIndex: u32 = 0; - ddsAttempt = 0; while ddsAttempt < bucketSize.wrapping_sub(1) { ddsAttempt = ddsAttempt.wrapping_add(1); @@ -657,12 +651,12 @@ unsafe fn ZSTD_dedicatedDictSearch_lazy_search( ); } - ddsAttempt = 0; + let mut ddsAttempt: u32 = 0; + let mut matchIndex: u32; while ddsAttempt < bucketLimit { let mut currentMl = 0; - let mut match_0 = core::ptr::null::(); matchIndex = *((*dms).hashTable).add(ddsIdx.wrapping_add(ddsAttempt as size_t)); - match_0 = ddsBase.offset(matchIndex as isize); + let match_0 = ddsBase.offset(matchIndex as isize); if matchIndex == 0 { return ml; } @@ -700,16 +694,14 @@ unsafe fn ZSTD_dedicatedDictSearch_lazy_search( chainAttempts }; let mut chainAttempt: u32 = 0; - chainAttempt = 0; while chainAttempt < chainLimit { chainAttempt = chainAttempt.wrapping_add(1); } chainAttempt = 0; while chainAttempt < chainLimit { let mut currentMl_0 = 0; - let mut match_1 = core::ptr::null::(); matchIndex = *((*dms).chainTable).offset(chainIndex_0 as isize); - match_1 = ddsBase.offset(matchIndex as isize); + let match_1 = ddsBase.offset(matchIndex as isize); if MEM_read32(match_1 as *const core::ffi::c_void) == MEM_read32(ip as *const core::ffi::c_void) { @@ -820,14 +812,13 @@ unsafe fn ZSTD_HcFindBestMatch( } else { 0 }; - let mut matchIndex: u32 = 0; if dictMode as core::ffi::c_uint == ZSTD_dedicatedDictSearch as core::ffi::c_int as core::ffi::c_uint { let entry: *const u32 = &mut *((*dms).hashTable).add(ddsIdx) as *mut u32; prefetch_read_data(entry, Locality::L1); } - matchIndex = + let mut matchIndex = ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, mls, ms.lazySkipping as u32); while (matchIndex >= lowLimit) as core::ffi::c_int & (nbAttempts > 0) as core::ffi::c_int != 0 { let mut currentMl = 0; @@ -1281,7 +1272,6 @@ unsafe fn ZSTD_RowFindBestMatch( let hashSalt = ms.hashSalt; let mut nbAttempts = (1 as core::ffi::c_uint) << cappedSearchLog; let mut ml = (4 - 1) as size_t; - let mut hash: u32 = 0; let dms = ms.dictMatchState; let mut ddsIdx = 0; let mut ddsExtraAttempts = 0; @@ -1320,20 +1310,20 @@ unsafe fn ZSTD_RowFindBestMatch( dmsRow = dmsHashTable.offset(dmsRelRow as isize); ZSTD_row_prefetch(dmsHashTable, dmsTagTable, dmsRelRow, rowLog); } - if ms.lazySkipping == 0 { + let hash = if ms.lazySkipping == 0 { ZSTD_row_update_internal(ms, ip, mls, rowLog, rowMask, 1); - hash = ZSTD_row_nextCachedHash( + ZSTD_row_nextCachedHash( hashCache, hashTable, tagTable, base, curr, hashLog, rowLog, mls, hashSalt, - ); + ) } else { - hash = ZSTD_hashPtrSalted( + ms.nextToUpdate = curr; + ZSTD_hashPtrSalted( ip as *const core::ffi::c_void, hashLog.wrapping_add(ZSTD_ROW_HASH_TAG_BITS as u32), mls, hashSalt, - ) as u32; - ms.nextToUpdate = curr; - } + ) as u32 + }; ms.hashSaltEntropy = (ms.hashSaltEntropy).wrapping_add(hash); let relRow = hash >> ZSTD_ROW_HASH_TAG_BITS << rowLog; let tag = hash & ZSTD_ROW_HASH_TAG_MASK; diff --git a/lib/compress/zstd_ldm.rs b/lib/compress/zstd_ldm.rs index eb5ace98..b244963f 100644 --- a/lib/compress/zstd_ldm.rs +++ b/lib/compress/zstd_ldm.rs @@ -553,11 +553,8 @@ unsafe fn ZSTD_ldm_gear_feed( ) -> size_t { let mut current_block: u64; let mut n: size_t = 0; - let mut hash: u64 = 0; - let mut mask: u64 = 0; - hash = (*state).rolling; - mask = (*state).stopMask; - n = 0; + let mut hash = (*state).rolling; + let mask = (*state).stopMask; loop { if n.wrapping_add(3) >= size { current_block = 5689316957504528238; @@ -887,20 +884,17 @@ pub unsafe fn ZSTD_ldm_fillHashTable( stopMask: 0, }; let splits = ((*ldmState).splitIndices).as_mut_ptr(); - let mut numSplits: core::ffi::c_uint = 0; ZSTD_ldm_gear_init(&mut hashState, params); while ip < iend { - let mut hashed: size_t = 0; let mut n: core::ffi::c_uint = 0; - numSplits = 0; - hashed = ZSTD_ldm_gear_feed( + let mut numSplits = 0; + let hashed = ZSTD_ldm_gear_feed( &mut hashState, ip, iend.offset_from_unsigned(ip), splits, &mut numSplits, ); - n = 0; while n < numSplits { if ip.add(*splits.offset(n as isize)) >= istart.offset(minMatchLength as isize) { let split = ip @@ -982,7 +976,6 @@ unsafe fn ZSTD_ldm_generateSequences_internal( }; let splits = ((*ldmState).splitIndices).as_mut_ptr(); let candidates = ((*ldmState).matchCandidates).as_mut_ptr(); - let mut numSplits: core::ffi::c_uint = 0; if srcSize < minMatchLength as size_t { return iend.offset_from_unsigned(anchor); } @@ -990,17 +983,15 @@ unsafe fn ZSTD_ldm_generateSequences_internal( ZSTD_ldm_gear_reset(&mut hashState, ip, minMatchLength as size_t); ip = ip.offset(minMatchLength as isize); while ip < ilimit { - let mut hashed: size_t = 0; - let mut n: core::ffi::c_uint = 0; - numSplits = 0; - hashed = ZSTD_ldm_gear_feed( + let mut numSplits: core::ffi::c_uint = 0; + let hashed = ZSTD_ldm_gear_feed( &mut hashState, ip, ilimit.offset_from_unsigned(ip), splits, &mut numSplits, ); - n = 0; + let mut n: core::ffi::c_uint = 0; while n < numSplits { let split = ip .add(*splits.offset(n as isize)) @@ -1024,13 +1015,10 @@ unsafe fn ZSTD_ldm_generateSequences_internal( let mut forwardMatchLength = 0; let mut backwardMatchLength = 0; let mut bestMatchLength = 0; - let mut mLength: size_t = 0; - let mut offset: u32 = 0; let split_0 = (*candidates.offset(n as isize)).split; let checksum = (*candidates.offset(n as isize)).checksum; let hash_0 = (*candidates.offset(n as isize)).hash; let bucket = (*candidates.offset(n as isize)).bucket; - let mut cur = core::ptr::null::(); let mut bestEntry = core::ptr::null(); let mut newEntry = ldmEntry_t { offset: 0, @@ -1047,11 +1035,10 @@ unsafe fn ZSTD_ldm_generateSequences_internal( ); } else { let mut current_block_30: u64; - cur = bucket; + let mut cur = bucket.cast_const(); while cur < bucket.offset(entsPerBucket as isize) as *const ldmEntry_t { - let mut curForwardMatchLength: size_t = 0; + let curForwardMatchLength: size_t; let mut curBackwardMatchLength: size_t = 0; - let mut curTotalMatchLength: size_t = 0; if !((*cur).checksum != checksum || (*cur).offset <= lowestIndex) { if extDict != 0 { let curMatchBase = if (*cur).offset < dictLimit { @@ -1103,7 +1090,7 @@ unsafe fn ZSTD_ldm_generateSequences_internal( match current_block_30 { 17788412896529399552 => {} _ => { - curTotalMatchLength = + let curTotalMatchLength = curForwardMatchLength.wrapping_add(curBackwardMatchLength); if curTotalMatchLength > bestMatchLength { bestMatchLength = curTotalMatchLength; @@ -1124,9 +1111,9 @@ unsafe fn ZSTD_ldm_generateSequences_internal( (*params).bucketSizeLog, ); } else { - offset = (split_0.offset_from(base) as core::ffi::c_long as u32) + let offset = (split_0.offset_from(base) as core::ffi::c_long as u32) .wrapping_sub((*bestEntry).offset); - mLength = forwardMatchLength.wrapping_add(backwardMatchLength); + let mLength = forwardMatchLength.wrapping_add(backwardMatchLength); let seq = ((*rawSeqStore).seq).add((*rawSeqStore).size); if (*rawSeqStore).size == (*rawSeqStore).capacity { return Error::dstSize_tooSmall.to_error_code(); @@ -1164,7 +1151,6 @@ unsafe fn ZSTD_ldm_generateSequences_internal( } unsafe fn ZSTD_ldm_reduceTable(table: *mut ldmEntry_t, size: u32, reducerValue: u32) { let mut u: u32 = 0; - u = 0; while u < size { if (*table.offset(u as isize)).offset < reducerValue { (*table.offset(u as isize)).offset = 0; @@ -1190,7 +1176,6 @@ pub unsafe fn ZSTD_ldm_generateSequences( .wrapping_add(!srcSize.is_multiple_of(kMaxChunkSize) as core::ffi::c_int as size_t); let mut chunk: size_t = 0; let mut leftoverSize = 0; - chunk = 0; while chunk < nbChunks && (*sequences).size < (*sequences).capacity { let chunkStart = istart.add(chunk * kMaxChunkSize); let remaining = iend.offset_from_unsigned(chunkStart); @@ -1200,7 +1185,6 @@ pub unsafe fn ZSTD_ldm_generateSequences( chunkStart.add(kMaxChunkSize) }; let chunkSize = chunkEnd.offset_from_unsigned(chunkStart); - let mut newLeftoverSize: size_t = 0; let prevSize = (*sequences).size; if ZSTD_window_needOverflowCorrection( (*ldmState).window, @@ -1227,7 +1211,7 @@ pub unsafe fn ZSTD_ldm_generateSequences( &mut (*ldmState).loadedDictEnd, core::ptr::null_mut(), ); - newLeftoverSize = ZSTD_ldm_generateSequences_internal( + let newLeftoverSize = ZSTD_ldm_generateSequences_internal( ldmState, sequences, params, @@ -1336,9 +1320,8 @@ pub unsafe fn ZSTD_ldm_blockCompress( if (*cParams).strategy as core::ffi::c_uint >= ZSTD_btopt as core::ffi::c_int as core::ffi::c_uint { - let mut lastLLSize: size_t = 0; ms.ldmSeqStore = rawSeqStore; - lastLLSize = blockCompressor.unwrap_unchecked()(ms, seqStore, rep, src, srcSize); + let lastLLSize = blockCompressor.unwrap_unchecked()(ms, seqStore, rep, src, srcSize); ZSTD_ldm_skipRawSeqStoreBytes(rawSeqStore, srcSize); return lastLLSize; } @@ -1353,7 +1336,6 @@ pub unsafe fn ZSTD_ldm_blockCompress( } ZSTD_ldm_limitTableUpdate(ms, ip); ZSTD_ldm_fillFastTables(ms, ip as *const core::ffi::c_void); - let mut i: core::ffi::c_int = 0; let newLitLength = blockCompressor.unwrap_unchecked()( ms, seqStore, @@ -1362,7 +1344,7 @@ pub unsafe fn ZSTD_ldm_blockCompress( sequence.litLength as size_t, ); ip = ip.offset(sequence.litLength as isize); - i = ZSTD_REP_NUM - 1; + let mut i = ZSTD_REP_NUM - 1; while i > 0 { *rep.offset(i as isize) = *rep.offset((i - 1) as isize); i -= 1; diff --git a/lib/compress/zstd_opt.rs b/lib/compress/zstd_opt.rs index 4da15ec1..07bceac3 100644 --- a/lib/compress/zstd_opt.rs +++ b/lib/compress/zstd_opt.rs @@ -176,7 +176,6 @@ unsafe fn ZSTD_setBasePrices(optPtr: *mut optState_t, optLevel: core::ffi::c_int unsafe fn sum_u32(table: *const core::ffi::c_uint, nbElts: size_t) -> u32 { let mut n: size_t = 0; let mut total = 0; - n = 0; while n < nbElts { total = (total as core::ffi::c_uint).wrapping_add(*table.add(n)) as u32 as u32; n = n.wrapping_add(1); @@ -191,7 +190,6 @@ unsafe fn ZSTD_downscaleStats( ) -> u32 { let mut s: u32 = 0; let mut sum = 0; - s = 0; while s < lastEltIndex.wrapping_add(1) { let base = (if base1 as core::ffi::c_uint != 0 { 1 @@ -238,9 +236,8 @@ unsafe fn ZSTD_rescaleFreqs( { (*optPtr).priceType = zop_dynamic; if compressedLiterals != 0 { - let mut lit: core::ffi::c_uint = 0; (*optPtr).litSum = 0; - lit = 0; + let mut lit: core::ffi::c_uint = 0; while lit <= MaxLit { let scaleLog = 11u32; let bitCost = HUF_getNbBitsFromCTable( @@ -259,7 +256,6 @@ unsafe fn ZSTD_rescaleFreqs( lit = lit.wrapping_add(1); } } - let mut ll: core::ffi::c_uint = 0; let mut llstate = FSE_CState_t { value: 0, stateTable: core::ptr::null::(), @@ -271,7 +267,7 @@ unsafe fn ZSTD_rescaleFreqs( ((*(*optPtr).symbolCosts).fse.litlengthCTable).as_ptr(), ); (*optPtr).litLengthSum = 0; - ll = 0; + let mut ll: core::ffi::c_uint = 0; while ll <= MaxLL { let scaleLog_0 = 10u32; let bitCost_0 = FSE_getMaxNbBits(llstate.symbolTT, ll); @@ -286,7 +282,6 @@ unsafe fn ZSTD_rescaleFreqs( as u32 as u32; ll = ll.wrapping_add(1); } - let mut ml: core::ffi::c_uint = 0; let mut mlstate = FSE_CState_t { value: 0, stateTable: core::ptr::null::(), @@ -298,7 +293,7 @@ unsafe fn ZSTD_rescaleFreqs( ((*(*optPtr).symbolCosts).fse.matchlengthCTable).as_ptr(), ); (*optPtr).matchLengthSum = 0; - ml = 0; + let mut ml: core::ffi::c_uint = 0; while ml <= MaxML { let scaleLog_1 = 10u32; let bitCost_1 = FSE_getMaxNbBits(mlstate.symbolTT, ml); @@ -313,7 +308,6 @@ unsafe fn ZSTD_rescaleFreqs( as u32 as u32; ml = ml.wrapping_add(1); } - let mut of: core::ffi::c_uint = 0; let mut ofstate = FSE_CState_t { value: 0, stateTable: core::ptr::null::(), @@ -325,7 +319,7 @@ unsafe fn ZSTD_rescaleFreqs( ((*(*optPtr).symbolCosts).fse.offcodeCTable).as_ptr(), ); (*optPtr).offCodeSum = 0; - of = 0; + let mut of: core::ffi::c_uint = 0; while of <= MaxOff { let scaleLog_2 = 10u32; let bitCost_2 = FSE_getMaxNbBits(ofstate.symbolTT, of); @@ -363,7 +357,6 @@ unsafe fn ZSTD_rescaleFreqs( ); (*optPtr).litLengthSum = sum_u32(baseLLfreqs.as_ptr(), (MaxLL + 1) as size_t); let mut ml_0: core::ffi::c_uint = 0; - ml_0 = 0; while ml_0 <= MaxML { *((*optPtr).matchLengthFreq).offset(ml_0 as isize) = 1; ml_0 = ml_0.wrapping_add(1); @@ -408,7 +401,6 @@ unsafe fn ZSTD_rawLiteralsCost( let mut price = (*optPtr).litSumBasePrice * litLength; let litPriceMax = ((*optPtr).litSumBasePrice).wrapping_sub(BITCOST_MULTIPLIER as u32); let mut u: u32 = 0; - u = 0; while u < litLength { let mut litPrice = if optLevel != 0 { ZSTD_fracWeight(*((*optPtr).litFreq).offset(*literals.offset(u as isize) as isize)) @@ -458,7 +450,6 @@ unsafe fn ZSTD_getMatchPrice( optPtr: *const optState_t, optLevel: core::ffi::c_int, ) -> u32 { - let mut price: u32 = 0; let offCode = ZSTD_highbit32(offBase); let mlBase = matchLength.wrapping_sub(MINMATCH as u32); if (*optPtr).priceType == zop_predef { @@ -469,7 +460,7 @@ unsafe fn ZSTD_getMatchPrice( }) .wrapping_add(16u32.wrapping_add(offCode) * BITCOST_MULTIPLIER as u32); } - price = (offCode * BITCOST_MULTIPLIER as u32).wrapping_add( + let mut price = (offCode * BITCOST_MULTIPLIER as u32).wrapping_add( ((*optPtr).offCodeSumBasePrice).wrapping_sub(if optLevel != 0 { ZSTD_fracWeight(*((*optPtr).offCodeFreq).offset(offCode as isize)) } else { @@ -503,7 +494,6 @@ unsafe fn ZSTD_updateStats( ) { if ZSTD_compressedLiterals(optPtr) != 0 { let mut u: u32 = 0; - u = 0; while u < litLength { let fresh2 = &mut (*((*optPtr).litFreq).offset(*literals.offset(u as isize) as isize)); *fresh2 = (*fresh2).wrapping_add(ZSTD_LITFREQ_ADD as core::ffi::c_uint); @@ -582,7 +572,6 @@ unsafe fn ZSTD_insertBt1( let dictLimit = (*ms).window.dictLimit; let dictEnd = dictBase.offset(dictLimit as isize); let prefixStart = base.offset(dictLimit as isize); - let mut match_0 = core::ptr::null::(); let curr = ip.offset_from(base) as core::ffi::c_long as u32; let btLow = if btMask >= curr { 0 @@ -604,6 +593,7 @@ unsafe fn ZSTD_insertBt1( } else { commonLengthLarger }; + let mut match_0: *const u8; if extDict == 0 || (matchIndex as size_t).wrapping_add(matchLength) >= dictLimit as size_t { match_0 = base.offset(matchIndex as isize); matchLength = matchLength.wrapping_add(ZSTD_count( @@ -831,8 +821,7 @@ unsafe fn ZSTD_insertBtAndGetAllMatches( }; let mut bestLength = lengthToBeat.wrapping_sub(1) as size_t; let lastR = (ZSTD_REP_NUM as u32).wrapping_add(ll0); - let mut repCode: u32 = 0; - repCode = ll0; + let mut repCode = ll0; while repCode < lastR { let repOffset = if repCode == ZSTD_REP_NUM as u32 { (*rep).wrapping_sub(1) @@ -924,18 +913,18 @@ unsafe fn ZSTD_insertBtAndGetAllMatches( & (curr.wrapping_sub(matchIndex3) < ((1) << 18) as u32) as core::ffi::c_int != 0 { - let mut mlen: size_t = 0; - if dictMode as core::ffi::c_uint == ZSTD_noDict as core::ffi::c_int as core::ffi::c_uint + let mlen = if dictMode as core::ffi::c_uint + == ZSTD_noDict as core::ffi::c_int as core::ffi::c_uint || dictMode as core::ffi::c_uint == ZSTD_dictMatchState as core::ffi::c_int as core::ffi::c_uint || matchIndex3 >= dictLimit { let match_0 = base.offset(matchIndex3 as isize); - mlen = ZSTD_count(ip, match_0, iLimit); + ZSTD_count(ip, match_0, iLimit) } else { let match_1 = dictBase.offset(matchIndex3 as isize); - mlen = ZSTD_count_2segments(ip, match_1, iLimit, dictEnd, prefixStart); - } + ZSTD_count_2segments(ip, match_1, iLimit, dictEnd, prefixStart) + }; if mlen >= mls as size_t { bestLength = mlen; (*matches).off = curr @@ -956,7 +945,7 @@ unsafe fn ZSTD_insertBtAndGetAllMatches( *hashTable.add(h) = curr; while nbCompares != 0 && matchIndex >= matchLow { let nextPtr = bt.offset((2 * (matchIndex & btMask)) as isize); - let mut match_2 = core::ptr::null::(); + let mut match_2; let mut matchLength = if commonLengthSmaller < commonLengthLarger { commonLengthSmaller } else { @@ -1616,27 +1605,19 @@ unsafe fn ZSTD_opt_getNextMatchAndUpdateSeqStore( currPosInBlock: u32, blockBytesRemaining: u32, ) { - let mut currSeq = rawSeq { - offset: 0, - litLength: 0, - matchLength: 0, - }; - let mut currBlockEndPos: u32 = 0; - let mut literalsBytesRemaining: u32 = 0; - let mut matchBytesRemaining: u32 = 0; if (*optLdm).seqStore.size == 0 || (*optLdm).seqStore.pos >= (*optLdm).seqStore.size { (*optLdm).startPosInBlock = UINT_MAX; (*optLdm).endPosInBlock = UINT_MAX; return; } - currSeq = *((*optLdm).seqStore.seq).add((*optLdm).seqStore.pos); - currBlockEndPos = currPosInBlock.wrapping_add(blockBytesRemaining); - literalsBytesRemaining = if (*optLdm).seqStore.posInSequence < currSeq.litLength as size_t { + let currSeq = *((*optLdm).seqStore.seq).add((*optLdm).seqStore.pos); + let currBlockEndPos = currPosInBlock.wrapping_add(blockBytesRemaining); + let literalsBytesRemaining = if (*optLdm).seqStore.posInSequence < currSeq.litLength as size_t { (currSeq.litLength).wrapping_sub((*optLdm).seqStore.posInSequence as u32) } else { 0 }; - matchBytesRemaining = if literalsBytesRemaining == 0 { + let matchBytesRemaining = if literalsBytesRemaining == 0 { (currSeq.matchLength) .wrapping_sub(((*optLdm).seqStore.posInSequence as u32).wrapping_sub(currSeq.litLength)) } else { @@ -1781,8 +1762,8 @@ unsafe fn ZSTD_compressBlock_opt_generic( ZSTD_rescaleFreqs(optStatePtr, src as *const u8, srcSize, optLevel); ip = ip.offset((ip == prefixStart) as core::ffi::c_int as isize); while ip < ilimit { - let mut cur: u32 = 0; - let mut last_pos = 0; + let mut cur: u32; + let mut last_pos; let litlen = ip.offset_from(anchor) as core::ffi::c_long as u32; let ll0 = (litlen == 0) as core::ffi::c_int as u32; let mut nbMatches = getAllMatches.unwrap_unchecked()( @@ -1823,16 +1804,14 @@ unsafe fn ZSTD_compressBlock_opt_generic( cur = 0; last_pos = maxML; } else { - let mut pos: u32 = 0; - let mut matchNb: u32 = 0; - pos = 1; + let mut pos: u32 = 1; while pos < minMatch { (*opt.offset(pos as isize)).price = ZSTD_MAX_PRICE; (*opt.offset(pos as isize)).mlen = 0; (*opt.offset(pos as isize)).litlen = litlen.wrapping_add(pos); pos = pos.wrapping_add(1); } - matchNb = 0; + let mut matchNb: u32 = 0; while matchNb < nbMatches { let offBase = (*matches.offset(matchNb as isize)).off; let end = (*matches.offset(matchNb as isize)).len; @@ -1977,7 +1956,6 @@ unsafe fn ZSTD_compressBlock_opt_generic( ll0_0, minMatch, ); - let mut matchNb_0: u32 = 0; ZSTD_optLdm_processMatchCandidate( &mut optLdm, matches, @@ -2001,7 +1979,7 @@ unsafe fn ZSTD_compressBlock_opt_generic( current_block = 12608488225262500095; break; } else { - matchNb_0 = 0; + let mut matchNb_0: u32 = 0; while matchNb_0 < nbMatches_0 { let offset = (*matches.offset(matchNb_0 as isize)).off; let lastML = (*matches.offset(matchNb_0 as isize)).len; @@ -2012,8 +1990,7 @@ unsafe fn ZSTD_compressBlock_opt_generic( } else { minMatch }; - let mut mlen: u32 = 0; - mlen = lastML; + let mut mlen = lastML; while mlen >= startML { let pos_0 = cur.wrapping_add(mlen); let price_0 = basePrice @@ -2084,7 +2061,7 @@ unsafe fn ZSTD_compressBlock_opt_generic( cur = cur.wrapping_sub(lastStretch.litlen); } let storeEnd = cur.wrapping_add(2); - let mut storeStart = storeEnd; + let mut storeStart; let mut stretchPos = cur; if lastStretch.litlen > 0 { (*opt.offset(storeEnd as isize)).litlen = lastStretch.litlen; @@ -2105,8 +2082,7 @@ unsafe fn ZSTD_compressBlock_opt_generic( stretchPos = stretchPos .wrapping_sub((nextStretch.litlen).wrapping_add(nextStretch.mlen)); } - let mut storePos: u32 = 0; - storePos = storeStart; + let mut storePos = storeStart; while storePos <= storeEnd { let llen = (*opt.offset(storePos as isize)).litlen; let mlen_0 = (*opt.offset(storePos as isize)).mlen; diff --git a/lib/compress/zstd_preSplit.rs b/lib/compress/zstd_preSplit.rs index 932421ef..e1da351b 100644 --- a/lib/compress/zstd_preSplit.rs +++ b/lib/compress/zstd_preSplit.rs @@ -144,7 +144,6 @@ unsafe fn ZSTD_splitBlock_byChunks( let fpstats = workspace as *mut FPStats; let p = blockStart as *const c_char; let mut penalty = THRESHOLD_PENALTY; - let mut pos = 0; debug_assert_eq!(blockSize, (128 << 10)); debug_assert!(!workspace.is_null()); @@ -158,7 +157,7 @@ unsafe fn ZSTD_splitBlock_byChunks( p as *const c_void, CHUNKSIZE as size_t, ); - pos = CHUNKSIZE as size_t; + let mut pos = CHUNKSIZE as size_t; while pos <= blockSize.wrapping_sub(CHUNKSIZE as size_t) { record_f( &mut (*fpstats).newEvents, diff --git a/lib/compress/zstdmt_compress.rs b/lib/compress/zstdmt_compress.rs index 4d105101..1e5f9573 100644 --- a/lib/compress/zstdmt_compress.rs +++ b/lib/compress/zstdmt_compress.rs @@ -186,7 +186,6 @@ unsafe fn ZSTD_rollingHash_append( ) -> u64 { let istart = buf as *const u8; let mut pos: size_t = 0; - pos = 0; while pos < size { hash *= prime8bytes; hash = hash.wrapping_add( @@ -281,7 +280,6 @@ unsafe fn ZSTDMT_freeBufferPool(bufPool: *mut ZSTDMT_bufferPool) { } if !((*bufPool).buffers).is_null() { let mut u: core::ffi::c_uint = 0; - u = 0; while u < (*bufPool).totalBuffers { ZSTD_customFree( (*((*bufPool).buffers).offset(u as isize)).start, @@ -335,7 +333,6 @@ unsafe fn ZSTDMT_sizeof_bufferPool(bufPool: *mut ZSTDMT_bufferPool) -> size_t { let mut u: core::ffi::c_uint = 0; let mut totalBufferSize = 0 as size_t; let _guard = (*bufPool).poolMutex.lock().unwrap(); - u = 0; while u < (*bufPool).totalBuffers { totalBufferSize = totalBufferSize.wrapping_add((*((*bufPool).buffers).offset(u as isize)).capacity); @@ -361,9 +358,8 @@ unsafe fn ZSTDMT_expandBufferPool( } let cMem = (*srcBufPool).cMem; let bSize = (*srcBufPool).bufferSize; - let mut newBufPool = core::ptr::null_mut::(); ZSTDMT_freeBufferPool(srcBufPool); - newBufPool = ZSTDMT_createBufferPool(maxNbBuffers, cMem); + let newBufPool = ZSTDMT_createBufferPool(maxNbBuffers, cMem); if newBufPool.is_null() { return newBufPool; } @@ -465,7 +461,6 @@ unsafe fn ZSTDMT_freeCCtxPool(pool: *mut ZSTDMT_CCtxPool) { core::ptr::drop_in_place(core::ptr::addr_of_mut!((*pool).poolMutex)); if !((*pool).cctxs).is_null() { let mut cid: core::ffi::c_int = 0; - cid = 0; while cid < (*pool).totalCCtx { ZSTD_freeCCtx(*((*pool).cctxs).offset(cid as isize)); cid += 1; @@ -534,7 +529,6 @@ unsafe fn ZSTDMT_sizeof_CCtxPool(cctxPool: *mut ZSTDMT_CCtxPool) -> size_t { let arraySize = ((*cctxPool).totalCCtx as usize).wrapping_mul(size_of::<*mut ZSTD_CCtx>()); let mut totalCCtxSize = 0 as size_t; let mut u: core::ffi::c_uint = 0; - u = 0; while u < nbWorkers { totalCCtxSize = totalCCtxSize.wrapping_add(ZSTD_sizeof_CCtx(*((*cctxPool).cctxs).offset(u as isize))); @@ -913,7 +907,6 @@ unsafe fn ZSTDMT_compressionJob(jobDescription: *mut core::ffi::c_void) { let ostart = dstBuff.start as *mut u8; let mut op = ostart; let oend = op.add(dstBuff.capacity); - let mut chunkNb: core::ffi::c_int = 0; if size_of::() > size_of::() { /* check overflow */ @@ -924,7 +917,7 @@ unsafe fn ZSTDMT_compressionJob(jobDescription: *mut core::ffi::c_void) { } assert!((*job).cSize == 0); - chunkNb = 1; + let mut chunkNb: core::ffi::c_int = 1; loop { if chunkNb >= nbChunks { current_block = 851619935621435220; @@ -1057,11 +1050,10 @@ unsafe fn ZSTDMT_freeJobsTable( nbJobs: u32, cMem: ZSTD_customMem, ) { - let mut jobNb: u32 = 0; if jobTable.is_null() { return; } - jobNb = 0; + let mut jobNb: u32 = 0; while jobNb < nbJobs { core::ptr::drop_in_place(core::ptr::addr_of_mut!( (*jobTable.offset(jobNb as isize)).job_mutex @@ -1083,7 +1075,6 @@ unsafe fn ZSTDMT_createJobsTable( ) -> *mut ZSTDMT_jobDescription { let nbJobsLog2 = (ZSTD_highbit32(*nbJobsPtr)).wrapping_add(1); let nbJobs = ((1) << nbJobsLog2) as u32; - let mut jobNb: u32 = 0; let jobTable = ZSTD_customCalloc( (nbJobs as usize).wrapping_mul(size_of::()), cMem, @@ -1092,7 +1083,7 @@ unsafe fn ZSTDMT_createJobsTable( return core::ptr::null_mut(); } *nbJobsPtr = nbJobs; - jobNb = 0; + let mut jobNb: u32 = 0; while jobNb < nbJobs { core::ptr::write( core::ptr::addr_of_mut!((*jobTable.offset(jobNb as isize)).job_mutex), @@ -1140,7 +1131,6 @@ unsafe fn ZSTDMT_createCCtx_advanced_internal( pool: *mut ZSTD_threadPool, ) -> *mut ZSTDMT_CCtx { let mut nbJobs = nbWorkers.wrapping_add(2); - let mut initError: core::ffi::c_int = 0; if nbWorkers < 1 { return core::ptr::null_mut(); } @@ -1183,7 +1173,7 @@ unsafe fn ZSTDMT_createCCtx_advanced_internal( ); (*mtctx).cctxPool = ZSTDMT_createCCtxPool(nbWorkers as core::ffi::c_int, cMem); (*mtctx).seqPool = ZSTDMT_createSeqPool(nbWorkers, cMem); - initError = ZSTDMT_serialState_init(&mut (*mtctx).serial); + let initError = ZSTDMT_serialState_init(&mut (*mtctx).serial); (*mtctx).roundBuff = kNullRoundBuff; if ((*mtctx).factory).is_null() as core::ffi::c_int | ((*mtctx).jobs).is_null() as core::ffi::c_int @@ -1207,7 +1197,6 @@ pub unsafe fn ZSTDMT_createCCtx_advanced( } unsafe fn ZSTDMT_releaseAllJobResources(mtctx: *mut ZSTDMT_CCtx) { let mut jobID: core::ffi::c_uint = 0; - jobID = 0; while jobID <= (*mtctx).jobIDMask { let mutex = core::ptr::read(core::ptr::addr_of!( (*((*mtctx).jobs).offset(jobID as isize)).job_mutex @@ -1364,9 +1353,8 @@ pub unsafe fn ZSTDMT_getFrameProgression(mtctx: *mut ZSTDMT_CCtx) -> ZSTD_frameP fps.produced = fps.flushed; fps.currentJobID = (*mtctx).nextJobID; fps.nbActiveWorkers = 0; - let mut jobNb: core::ffi::c_uint = 0; let lastJobNb = ((*mtctx).nextJobID).wrapping_add((*mtctx).jobReady as core::ffi::c_uint); - jobNb = (*mtctx).doneJobID; + let mut jobNb = (*mtctx).doneJobID; while jobNb < lastJobNb { let wJobID = jobNb & (*mtctx).jobIDMask; let jobPtr: *mut ZSTDMT_jobDescription = @@ -1391,7 +1379,6 @@ pub unsafe fn ZSTDMT_getFrameProgression(mtctx: *mut ZSTDMT_CCtx) -> ZSTD_frameP fps } pub unsafe fn ZSTDMT_toFlushNow(mtctx: *mut ZSTDMT_CCtx) -> size_t { - let mut toFlush: size_t = 0; let jobID = (*mtctx).doneJobID; if jobID == (*mtctx).nextJobID { return 0; @@ -1407,30 +1394,29 @@ pub unsafe fn ZSTDMT_toFlushNow(mtctx: *mut ZSTDMT_CCtx) -> size_t { } else { (*jobPtr).dstFlushed }; - toFlush = produced.wrapping_sub(flushed); + let toFlush = produced.wrapping_sub(flushed); if toFlush == 0 { assert!((*jobPtr).consumed < (*jobPtr).src.size); } toFlush } unsafe fn ZSTDMT_computeTargetJobLog(params: *const ZSTD_CCtx_params) -> core::ffi::c_uint { - let mut jobLog: core::ffi::c_uint = 0; - if (*params).ldmParams.enableLdm == ZSTD_ParamSwitch_e::ZSTD_ps_enable { - jobLog = if 21 + let jobLog = if (*params).ldmParams.enableLdm == ZSTD_ParamSwitch_e::ZSTD_ps_enable { + if 21 > (ZSTD_cycleLog((*params).cParams.chainLog, (*params).cParams.strategy)) .wrapping_add(3) { 21 } else { (ZSTD_cycleLog((*params).cParams.chainLog, (*params).cParams.strategy)).wrapping_add(3) - }; + } } else { - jobLog = if 20 > ((*params).cParams.windowLog).wrapping_add(2) { + if 20 > ((*params).cParams.windowLog).wrapping_add(2) { 20 } else { ((*params).cParams.windowLog).wrapping_add(2) - }; - } + } + }; if jobLog < (if MEM_32bits() { 29 } else { 30 }) as core::ffi::c_uint { jobLog } else { @@ -1835,21 +1821,19 @@ unsafe fn ZSTDMT_flushProduced( unsafe fn ZSTDMT_getInputDataInUse(mtctx: *mut ZSTDMT_CCtx) -> Range { let firstJobID = (*mtctx).doneJobID; let lastJobID = (*mtctx).nextJobID; - let mut jobID: core::ffi::c_uint = 0; let roundBuffCapacity = (*mtctx).roundBuff.capacity; let nbJobs1stRoundMin = roundBuffCapacity / (*mtctx).targetSectionSize; if (lastJobID as size_t) < nbJobs1stRoundMin { return kNullRange; } - jobID = firstJobID; + let mut jobID = firstJobID; while jobID < lastJobID { let wJobID = jobID & (*mtctx).jobIDMask; - let mut consumed: size_t = 0; let guard = (*((*mtctx).jobs).offset(wJobID as isize)) .job_mutex .lock() .unwrap(); - consumed = (*((*mtctx).jobs).offset(wJobID as isize)).consumed; + let consumed = (*((*mtctx).jobs).offset(wJobID as isize)).consumed; drop(guard); if consumed < (*((*mtctx).jobs).offset(wJobID as isize)).src.size { let mut range = (*((*mtctx).jobs).offset(wJobID as isize)).prefix; @@ -1940,9 +1924,6 @@ unsafe fn findSynchronizationPoint(mtctx: *const ZSTDMT_CCtx, input: ZSTD_inBuff toLoad: 0, flush: 0, }; - let mut hash: u64 = 0; - let mut prev = core::ptr::null::(); - let mut pos: size_t = 0; syncPoint.toLoad = if (input.size).wrapping_sub(input.pos) < ((*mtctx).targetSectionSize).wrapping_sub((*mtctx).inBuff.filled) { @@ -1964,6 +1945,9 @@ unsafe fn findSynchronizationPoint(mtctx: *const ZSTDMT_CCtx, input: ZSTD_inBuff if ((*mtctx).inBuff.filled).wrapping_add(syncPoint.toLoad) < RSYNC_LENGTH as size_t { return syncPoint; } + let mut hash: u64; + let prev: *const u8; + let mut pos: size_t; if (*mtctx).inBuff.filled < RSYNC_MIN_BLOCK_SIZE as size_t { pos = (RSYNC_MIN_BLOCK_SIZE as size_t).wrapping_sub((*mtctx).inBuff.filled); if pos >= RSYNC_LENGTH as size_t { @@ -2002,11 +1986,9 @@ unsafe fn findSynchronizationPoint(mtctx: *const ZSTDMT_CCtx, input: ZSTD_inBuff if hash & hitMask == hitMask { syncPoint.toLoad = pos.wrapping_add(1); syncPoint.flush = 1; - pos = pos.wrapping_add(1); break; - } else { - pos = pos.wrapping_add(1); } + pos = pos.wrapping_add(1); } syncPoint } diff --git a/lib/decompress/huf_decompress.rs b/lib/decompress/huf_decompress.rs index 447a436f..29bacdba 100644 --- a/lib/decompress/huf_decompress.rs +++ b/lib/decompress/huf_decompress.rs @@ -340,11 +340,10 @@ pub fn HUF_readDTableX1_wksp( let mut tableLog = 0; let mut nbSymbols = 0; - let mut iSize: size_t = 0; let wksp = workSpace.as_x1_mut(); - iSize = HUF_readStats_wksp( + let iSize = HUF_readStats_wksp( &mut wksp.huffWeight, (HUF_SYMBOLVALUE_MAX + 1) as size_t, &mut wksp.rankVal, @@ -1043,7 +1042,6 @@ pub fn HUF_readDTableX2_wksp( let mut tableLog: u32 = 0; let mut nbSymbols: u32 = 0; let mut maxTableLog = dtd.maxTableLog as u32; - let mut iSize: size_t = 0; let dt = DTable.data.as_x2_mut(); @@ -1055,7 +1053,7 @@ pub fn HUF_readDTableX2_wksp( return Error::tableLog_tooLarge.to_error_code(); } - iSize = HUF_readStats_wksp( + let iSize = HUF_readStats_wksp( &mut wksp.weightList, (HUF_SYMBOLVALUE_MAX + 1) as size_t, &mut wksp.rankStats, @@ -1121,8 +1119,7 @@ pub fn HUF_readDTableX2_wksp( } let minBits = tableLog.wrapping_add(1).wrapping_sub(maxW); - let mut consumed: u32 = 0; - consumed = minBits; + let mut consumed = minBits; while consumed < maxTableLog.wrapping_sub(minBits).wrapping_add(1) { for w in 1..maxW.wrapping_add(1) as usize { wksp.rankVal[consumed as usize][w] = wksp.rankVal[0][w] >> consumed; @@ -1459,8 +1456,6 @@ unsafe extern "C" fn HUF_decompress4X2_usingDTable_internal_fast_c_loop( oend[3] = args.oend; 'out: loop { - let mut olimit = core::ptr::null_mut::(); - /* Assert loop preconditions */ if cfg!(debug_assertions) { for stream in 0..4 { @@ -1496,7 +1491,7 @@ unsafe extern "C" fn HUF_decompress4X2_usingDTable_internal_fast_c_loop( * at the expense of computing the remaining # of iterations * more frequently. */ - olimit = op[3].add(iters * 5); + let olimit = op[3].add(iters * 5); /* Exit the fast decoding loop once we reach the end. */ if op[3] == olimit { diff --git a/lib/decompress/zstd_decompress.rs b/lib/decompress/zstd_decompress.rs index d42d9eb5..9c526335 100644 --- a/lib/decompress/zstd_decompress.rs +++ b/lib/decompress/zstd_decompress.rs @@ -225,12 +225,11 @@ fn ZSTD_decompressLegacy( src.as_ptr() as *const core::ffi::c_void }; - let mut result: size_t = 0; let zd = unsafe { ZSTDv06_createDCtx() }; if zd.is_null() { return Err(Error::memory_allocation); } - result = unsafe { + let result = unsafe { ZSTDv06_decompress_usingDict( zd, dst, @@ -526,14 +525,13 @@ unsafe fn ZSTD_DDictHashSet_expand( ) as *mut *const ZSTD_DDict; let oldTable = hashSet.ddictPtrTable; let oldTableSize = hashSet.ddictPtrTableSize; - let mut i: size_t = 0; if newTable.is_null() { return Error::memory_allocation.to_error_code(); } hashSet.ddictPtrTable = newTable; hashSet.ddictPtrTableSize = newTableSize; hashSet.ddictPtrCount = 0; - i = 0; + let mut i: size_t = 0; while i < oldTableSize { if !(*oldTable.add(i)).is_null() { let err_code = ZSTD_DDictHashSet_emplaceDDict(hashSet, *oldTable.add(i)); @@ -2040,12 +2038,11 @@ pub unsafe extern "C" fn ZSTD_decompress( src: *const core::ffi::c_void, srcSize: size_t, ) -> size_t { - let mut regenSize: size_t = 0; let dctx = ZSTD_createDCtx_internal(ZSTD_customMem::default()); if dctx.is_null() { return Error::memory_allocation.to_error_code(); } - regenSize = ZSTD_decompressDCtx(dctx, dst, dstCapacity, src, srcSize); + let regenSize = ZSTD_decompressDCtx(dctx, dst, dstCapacity, src, srcSize); ZSTD_freeDCtx(dctx); regenSize } @@ -2193,7 +2190,7 @@ fn decompress_continue( } DecompressStage::DecompressBlock | DecompressStage::DecompressLastBlock => { - let mut rSize: size_t = 0; + let rSize: size_t; match dctx.bType { BlockType::Compressed => { debug_assert!(dctx.isFrameDecompression); diff --git a/lib/decompress/zstd_decompress_block.rs b/lib/decompress/zstd_decompress_block.rs index efa58a64..c6b4071e 100644 --- a/lib/decompress/zstd_decompress_block.rs +++ b/lib/decompress/zstd_decompress_block.rs @@ -1616,7 +1616,7 @@ fn ZSTD_decodeSequence( // it is deliberately not a debug_assert!. assert!(ofBits as u32 <= MaxOff); - let mut offset: size_t = 0; + let mut offset: size_t; if ofBits > 1 { const { assert!(Offset::Long as usize == 1) }; const { assert!(LONG_OFFSETS_MAX_EXTRA_BITS_32 == 5) }; diff --git a/lib/dictBuilder/cover.rs b/lib/dictBuilder/cover.rs index 6952ba8e..acc2d01c 100644 --- a/lib/dictBuilder/cover.rs +++ b/lib/dictBuilder/cover.rs @@ -10,8 +10,8 @@ use crate::lib::common::bits::ZSTD_highbit32; use crate::lib::common::error_private::{ERR_isError, Error}; use crate::lib::common::pool::{POOL_add, POOL_create, POOL_free}; use crate::lib::compress::zstd_compress::{ - ZSTD_CCtx, ZSTD_CDict, ZSTD_compressBound, ZSTD_compress_usingCDict, ZSTD_createCCtx, - ZSTD_createCDict, ZSTD_freeCCtx, ZSTD_freeCDict, + ZSTD_compressBound, ZSTD_compress_usingCDict, ZSTD_createCCtx, ZSTD_createCDict, ZSTD_freeCCtx, + ZSTD_freeCDict, }; use crate::lib::dictBuilder::zdict::{ZDICT_finalizeDictionary, ZDICT_isError}; use crate::lib::zdict::experimental::{ZDICT_cover_params_t, ZDICT_DICTSIZE_MIN}; @@ -319,6 +319,7 @@ type __compar_d_fn_t = unsafe extern "C" fn( ) -> core::ffi::c_int; fn stableSort(ctx: &mut COVER_ctx_t) { + #[allow(unused_variables)] let compare_fn = if ctx.d <= 8 { COVER_strict_cmp8 as __compar_d_fn_t } else { @@ -484,8 +485,7 @@ fn COVER_selectSegment( } let mut newBegin = bestSegment.end; let mut newEnd = bestSegment.begin; - let mut pos: u32 = 0; - pos = bestSegment.begin; + let mut pos = bestSegment.begin; while pos != bestSegment.end { let freq = freqs[ctx.dmerAt[pos as usize] as usize]; if freq != 0 { @@ -496,8 +496,7 @@ fn COVER_selectSegment( } bestSegment.begin = newBegin; bestSegment.end = newEnd; - let mut pos_0: u32 = 0; - pos_0 = bestSegment.begin; + let mut pos_0 = bestSegment.begin; while pos_0 != bestSegment.end { freqs[ctx.dmerAt[pos_0 as usize] as usize] = 0; pos_0 = pos_0.wrapping_add(1); @@ -634,9 +633,8 @@ fn COVER_ctx_init<'a>( ctx.offsets = Box::from(vec![0usize; nbSamples + 1]); ctx.freqs = Box::default(); ctx.d = d; - let mut i: usize = 0; ctx.offsets[0] = 0; - i = 1; + let mut i: usize = 1; while i <= nbSamples { ctx.offsets[i] = ctx.offsets[i.wrapping_sub(1)].wrapping_add(samplesSizes[i.wrapping_sub(1)]); @@ -726,7 +724,6 @@ fn COVER_buildDictionary<'a>( ); let maxZeroScoreRun = (epochs.num >> 3).clamp(10, 100) as size_t; let mut zeroScoreRun = 0 as size_t; - let mut epoch: size_t = 0; let mut last_update_time = Instant::now(); let displayLevel = ctx.displayLevel; if displayLevel >= 2 { @@ -735,11 +732,10 @@ fn COVER_buildDictionary<'a>( epochs.num, epochs.size, ); } - epoch = 0; + let mut epoch: size_t = 0; while tail > 0 { let epochBegin = (epoch * epochs.size as size_t) as u32; let epochEnd = epochBegin.wrapping_add(epochs.size); - let mut segmentSize: size_t = 0; let segment = COVER_selectSegment(ctx, freqs, activeDmers, epochBegin, epochEnd, parameters); if segment.score == 0 { @@ -750,7 +746,7 @@ fn COVER_buildDictionary<'a>( } else { zeroScoreRun = 0; /* Trim the segment if necessary and if it is too small then we are done */ - segmentSize = Ord::min( + let segmentSize = Ord::min( (segment.end - segment.begin + parameters.d - 1) as usize, tail, ); @@ -946,12 +942,8 @@ pub(super) fn COVER_checkTotalCompressedSize( dictBufferCapacity: size_t, ) -> size_t { let mut totalCompressedSize = Error::GENERIC.to_error_code(); - let mut cctx = core::ptr::null_mut::(); - let mut cdict = core::ptr::null_mut::(); - let mut dstCapacity: size_t = 0; - let mut i: size_t = 0; let mut maxSampleSize = 0; - i = if parameters.splitPoint < 1.0f64 { + let mut i = if parameters.splitPoint < 1.0f64 { nbTrainSamples } else { 0 @@ -964,10 +956,10 @@ pub(super) fn COVER_checkTotalCompressedSize( }; i = i.wrapping_add(1); } - dstCapacity = ZSTD_compressBound(maxSampleSize); + let dstCapacity = ZSTD_compressBound(maxSampleSize); let mut dst: Box<[MaybeUninit]> = Box::new_uninit_slice(dstCapacity); - cctx = unsafe { ZSTD_createCCtx() }; - cdict = unsafe { + let cctx = unsafe { ZSTD_createCCtx() }; + let cdict = unsafe { ZSTD_createCDict( dict as *const core::ffi::c_void, dictBufferCapacity, @@ -1029,10 +1021,9 @@ pub(super) fn COVER_best_finish( ) { let compressedSize = selection.totalCompressedSize; let dictSize = selection.dictSize; - let mut liveJobs: size_t = 0; let mut guard = best.mutex.lock().unwrap(); guard.liveJobs = (guard.liveJobs).wrapping_sub(1); - liveJobs = guard.liveJobs; + let liveJobs = guard.liveJobs; if compressedSize < guard.compressedSize { if let Some(slice) = guard.dict.get_mut(..selection.dictContent.len()) { slice.copy_from_slice(&selection.dictContent); @@ -1082,10 +1073,8 @@ pub(super) fn COVER_selectDict( nbSamples: size_t, params: ZDICT_cover_params_t, offsets: &[size_t], - mut totalCompressedSize: size_t, + _totalCompressedSize: size_t, ) -> COVER_dictSelection_t { - let mut largestDict = 0; - let mut largestCompressed = 0; let mut largestDictbuffer: Box<[u8]> = Box::from(vec![0u8; dictBufferCapacity]); let mut candidateDictBuffer: Box<[u8]> = Box::from(vec![0u8; dictBufferCapacity]); let regressionTolerance = @@ -1108,7 +1097,7 @@ pub(super) fn COVER_selectDict( drop(candidateDictBuffer); return COVER_dictSelectionError(dictContentSize); } - totalCompressedSize = COVER_checkTotalCompressedSize( + let mut totalCompressedSize = COVER_checkTotalCompressedSize( params, samplesSizes, samplesBuffer, @@ -1127,8 +1116,8 @@ pub(super) fn COVER_selectDict( drop(candidateDictBuffer); return setDictSelection(largestDictbuffer, dictContentSize, totalCompressedSize); } - largestDict = dictContentSize; - largestCompressed = totalCompressedSize; + let largestDict = dictContentSize; + let largestCompressed = totalCompressedSize; dictContentSize = ZDICT_DICTSIZE_MIN; while dictContentSize < largestDict { candidateDictBuffer[..largestDict].copy_from_slice(&largestDictbuffer[..largestDict]); @@ -1190,7 +1179,7 @@ fn COVER_tryParameters(data: Box) { let dictBufferCapacity = data.dictBufferCapacity; let totalCompressedSize = Error::GENERIC.to_error_code(); let mut dict: Box<[MaybeUninit]> = Box::new_uninit_slice(dictBufferCapacity); - let mut selection = COVER_dictSelectionError(Error::GENERIC.to_error_code()); + let _selection = COVER_dictSelectionError(Error::GENERIC.to_error_code()); let mut freqs = ctx.freqs.clone(); let displayLevel = ctx.displayLevel; let mut activeDmers = @@ -1198,7 +1187,7 @@ fn COVER_tryParameters(data: Box) { let dict_tail = COVER_buildDictionary(ctx, &mut freqs, &mut activeDmers, &mut dict, parameters); - selection = COVER_selectDict( + let selection = COVER_selectDict( dict_tail, dictBufferCapacity, dict_tail.len(), diff --git a/lib/dictBuilder/divsufsort.rs b/lib/dictBuilder/divsufsort.rs index fdd229f4..8c0a135d 100644 --- a/lib/dictBuilder/divsufsort.rs +++ b/lib/dictBuilder/divsufsort.rs @@ -12,17 +12,10 @@ fn sort_typeBstar( n: i32, _openMP: bool, ) -> i32 { - let mut i: i32 = 0; - let mut j: i32 = 0; - let mut k: i32 = 0; - let mut t: i32 = 0; - let mut m: i32 = 0; - let mut c0: i32 = 0; - let mut c1: i32 = 0; - - i = n - 1; - m = n; - c0 = T[(n - 1) as usize] as i32; + let mut i = n - 1; + let mut m = n; + let mut c0 = T[(n - 1) as usize] as i32; + let mut c1: i32; while 0 <= i { loop { c1 = c0; @@ -54,7 +47,8 @@ fn sort_typeBstar( m = n - m; c0 = 0; i = 0; - j = 0; + let mut j = 0; + let mut t: i32; while c0 < ALPHABET_SIZE { t = i + bucket_A[c0 as usize]; bucket_A[c0 as usize] = i + j; @@ -170,7 +164,7 @@ fn sort_typeBstar( } bucket_B[(((256 - 1) << 8) | (256 - 1)) as usize] = n; c0 = ALPHABET_SIZE - 2; - k = m - 1; + let mut k = m - 1; while 0 <= c0 { i = bucket_A[(c0 + 1) as usize] - 1; c1 = ALPHABET_SIZE - 1; @@ -202,26 +196,22 @@ fn construct_SA( n: i32, m: i32, ) { - let mut s: i32 = 0; - let mut c0: i32 = 0; - let mut c1: i32 = 0; - let mut c2: i32 = 0; if (0) < m { - c1 = ALPHABET_SIZE - 2; + let mut c1 = ALPHABET_SIZE - 2; while 0 <= c1 { let mut k = i32::MIN; let i = bucket_B[((c1 << 8) | (c1 + 1)) as usize]; let mut j = bucket_A[(c1 + 1) as usize] - 1; - c2 = -1; + let mut c2 = -1; while i <= j { - s = SA[j as usize]; + let mut s = SA[j as usize]; if (0) < s { assert_eq!(T[s as usize] as i32, c1); assert!((s + 1) < n && T[s as usize] as i32 <= T[(s + 1) as usize] as i32); assert!(T[(s - 1) as usize] as i32 <= T[s as usize] as i32); SA[j as usize] = !s; s -= 1; - c0 = T[s as usize] as i32; + let c0 = T[s as usize] as i32; if (0) < s && T[(s - 1) as usize] as i32 > c0 { s = !s; } @@ -245,7 +235,7 @@ fn construct_SA( c1 -= 1; } } - c2 = T[(n - 1) as usize] as i32; + let mut c2 = T[(n - 1) as usize] as i32; let mut k = bucket_A[c2 as usize] as usize; SA[k] = if (T[(n - 2) as usize] as i32) < c2 { @@ -259,11 +249,11 @@ fn construct_SA( let j = n as usize; while i < j { - s = SA[i]; + let mut s = SA[i]; if (0) < s { assert!(T[(s - 1) as usize] as i32 >= T[s as usize] as i32); s -= 1; - c0 = T[s as usize] as i32; + let c0 = T[s as usize] as i32; if s == 0 || (T[(s - 1) as usize] as i32) < c0 { s = !s; } @@ -287,7 +277,7 @@ pub(super) fn divsufsort(T: &[u8], SA: &mut [i32], openMP: bool) -> i32 { assert_eq!(T.len(), SA.len()); let n = T.len(); - let mut m: i32 = 0; + let m: i32; if n == 0 { return 0; diff --git a/lib/dictBuilder/fastcover.rs b/lib/dictBuilder/fastcover.rs index 4c592fae..def73409 100644 --- a/lib/dictBuilder/fastcover.rs +++ b/lib/dictBuilder/fastcover.rs @@ -152,8 +152,7 @@ fn FASTCOVER_selectSegment( segmentFreqs[delIndex_0] -= 1; activeSegment.begin += 1; } - let mut pos: u32 = 0; - pos = bestSegment.begin; + let mut pos = bestSegment.begin; while pos != bestSegment.end { let i = FASTCOVER_hashPtrToIndex(samples[pos as usize..][..8].try_into().unwrap(), f, d); freqs[i] = 0; @@ -204,7 +203,6 @@ fn FASTCOVER_computeFrequency(ctx: &mut FASTCOVER_ctx_t) { let skip = ctx.accelParams.skip; let readLength = if d > 8 { d } else { 8 }; let mut i: size_t = 0; - i = 0; while i < ctx.nbTrainSamples { let mut start = ctx.offsets[i]; let currSampleEnd = ctx.offsets[i + 1]; @@ -338,18 +336,16 @@ fn FASTCOVER_buildDictionary<'a>( let displayLevel = ctx.displayLevel; let mut zeroScoreRun = 0 as size_t; let mut last_update_time = Instant::now(); - let mut epoch: size_t = 0; if displayLevel >= 2 { eprintln!( "Breaking content into {} epochs of size {}", epochs.num, epochs.size, ); } - epoch = 0; + let mut epoch: size_t = 0; while tail > 0 { let epochBegin = (epoch * epochs.size as size_t) as u32; let epochEnd = epochBegin.wrapping_add(epochs.size); - let mut segmentSize: size_t = 0; let segment = FASTCOVER_selectSegment(ctx, freqs, epochBegin, epochEnd, parameters, segmentFreqs); if segment.score == 0 { @@ -360,7 +356,7 @@ fn FASTCOVER_buildDictionary<'a>( } else { zeroScoreRun = 0; /* Trim the segment if necessary and if it is too small then we are done */ - segmentSize = Ord::min( + let segmentSize = Ord::min( (segment.end - segment.begin + parameters.d - 1) as usize, tail, ); @@ -403,7 +399,7 @@ fn FASTCOVER_tryParameters(data: Box) { let totalCompressedSize = Error::GENERIC.to_error_code(); let mut segmentFreqs: Box<[u16]> = Box::from(vec![0u16; 1 << ctx.f]); let mut dict: Box<[MaybeUninit]> = Box::new_uninit_slice(dictBufferCapacity); - let mut selection = COVER_dictSelectionError(Error::GENERIC.to_error_code()); + let _selection = COVER_dictSelectionError(Error::GENERIC.to_error_code()); let displayLevel = ctx.displayLevel; let mut freqs = ctx.freqs.clone(); @@ -412,7 +408,7 @@ fn FASTCOVER_tryParameters(data: Box) { FASTCOVER_buildDictionary(ctx, &mut freqs, &mut dict, parameters, &mut segmentFreqs); let nbFinalizeSamples = (ctx.nbTrainSamples * ctx.accelParams.finalize as size_t / 100) as core::ffi::c_uint; - selection = COVER_selectDict( + let selection = COVER_selectDict( dict_tail, dictBufferCapacity, dict_tail.len(), diff --git a/lib/dictBuilder/zdict.rs b/lib/dictBuilder/zdict.rs index a821f778..3be1c54d 100644 --- a/lib/dictBuilder/zdict.rs +++ b/lib/dictBuilder/zdict.rs @@ -186,26 +186,24 @@ fn ZDICT_analyzePos( } // look forward - let mut length: size_t = 0; loop { end = end.wrapping_add(1); - length = ZDICT_count(&buffer[pos..], &buffer[suffix(end as usize) as usize..]); + let length = ZDICT_count(&buffer[pos..], &buffer[suffix(end as usize) as usize..]); if length < MINMATCHLENGTH { break; } } // look backward - let mut length_0: size_t = 0; loop { - length_0 = ZDICT_count( + let length = ZDICT_count( &buffer[pos..], &buffer[suffix((start as usize).wrapping_sub(1)) as usize..], ); - if length_0 >= MINMATCHLENGTH { + if length >= MINMATCHLENGTH { start = start.wrapping_sub(1); } - if length_0 < MINMATCHLENGTH { + if length < MINMATCHLENGTH { break; } } @@ -218,8 +216,6 @@ fn ZDICT_analyzePos( return solution; } - let mut i: core::ffi::c_int = 0; - let mut mml: u32 = 0; let mut refinedStart = start; let mut refinedEnd = end; @@ -234,7 +230,7 @@ fn ZDICT_analyzePos( eprintln!(); } - mml = MINMATCHLENGTH as u32; + let mut mml = MINMATCHLENGTH as u32; loop { let mut currentChar = 0; let mut currentCount = 0u32; @@ -304,14 +300,13 @@ fn ZDICT_analyzePos( // largest useful length let mut cumulLength = [0u32; LLIMIT]; cumulLength[maxLength.wrapping_sub(1)] = lengthList[maxLength - 1]; - i = maxLength.wrapping_sub(2) as core::ffi::c_int; + let mut i = maxLength.wrapping_sub(2) as core::ffi::c_int; while i >= 0 { cumulLength[i as usize] = (cumulLength[(i + 1) as usize]).wrapping_add(lengthList[i as usize]); i -= 1; } - let mut u_0: core::ffi::c_uint = 0; - u_0 = (LLIMIT - 1) as core::ffi::c_uint; + let mut u_0 = (LLIMIT - 1) as core::ffi::c_uint; while u_0 >= MINMATCHLENGTH as core::ffi::c_uint { if cumulLength[u_0 as usize] >= minRatio as u32 { break; @@ -356,8 +351,7 @@ fn ZDICT_analyzePos( // mark positions done for id_0 in start..end { - let mut pEnd: u32 = 0; - let mut length_3: u32 = 0; + let mut length_3: u32; let testedPos = suffix(id_0 as usize); if testedPos as size_t == pos { length_3 = solution.length; @@ -367,7 +361,7 @@ fn ZDICT_analyzePos( length_3 = solution.length; } } - pEnd = testedPos.wrapping_add(length_3); + let pEnd = testedPos.wrapping_add(length_3); doneMarks[testedPos as usize..pEnd as usize].fill(true); } @@ -494,12 +488,11 @@ fn ZDICT_insertDictItem(table: &mut [DictItem], elt: DictItem, buffer: &[u8]) { } // insert - let mut current: u32 = 0; let mut nextElt = table[0].pos; if nextElt >= maxSize { nextElt = maxSize.wrapping_sub(1); } - current = nextElt.wrapping_sub(1); + let mut current = nextElt.wrapping_sub(1); while (table[current as usize]).savings < elt.savings { table[current.wrapping_add(1) as usize] = table[current as usize]; current = current.wrapping_sub(1); diff --git a/lib/legacy/zstd_v05.rs b/lib/legacy/zstd_v05.rs index e3aec99f..98e64879 100644 --- a/lib/legacy/zstd_v05.rs +++ b/lib/legacy/zstd_v05.rs @@ -460,7 +460,6 @@ fn FSEv05_buildDTable( } for s in 0..maxSymbolValue + 1 { let mut i: core::ffi::c_int = 0; - i = 0; while i < normalizedCounter[s as usize] as core::ffi::c_int { tableDecode[position as usize].symbol = s as u8; position = position.wrapping_add(step) & tableMask; @@ -557,7 +556,7 @@ unsafe fn FSEv05_readNCount( } } let max = (2 * threshold - 1 - remaining) as core::ffi::c_short; - let mut count: core::ffi::c_short = 0; + let mut count: core::ffi::c_short; if (bitStream & (threshold - 1) as u32) < max as u32 { count = (bitStream & (threshold - 1) as u32) as core::ffi::c_short; bitCount += nbBits - 1; @@ -754,12 +753,11 @@ fn HUFv05_readStats( src: &[u8], ) -> Result { let mut ip = src; - let mut iSize: size_t = 0; - let mut oSize: size_t = 0; if src.is_empty() { return Err(Error::srcSize_wrong); } - iSize = ip[0] as size_t; + let mut iSize = ip[0] as size_t; + let oSize: size_t; if iSize >= 128 { if iSize >= 242 { static l: [core::ffi::c_int; 14] = [1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128]; @@ -854,11 +852,10 @@ unsafe fn HUFv05_readDTableX2(DTable: *mut u16, src: &[u8]) -> Result> 1) as u32; - let mut i: u32 = 0; let mut D = HUFv05_DEltX2 { byte: 0, nbBits: 0 }; D.byte = n as u8; D.nbBits = tableLog.wrapping_add(1).wrapping_sub(w) as u8; - i = *rankVal.as_mut_ptr().offset(w as isize); + let mut i = *rankVal.as_mut_ptr().offset(w as isize); while i < (*rankVal.as_mut_ptr().offset(w as isize)).wrapping_add(length) { *dt.offset(i as isize) = D; i = i.wrapping_add(1); @@ -1116,12 +1113,11 @@ fn HUFv05_fillDTableX4Level2( }; let mut rankVal: [u32; 17] = *rankValOrigin; if minWeight > 1 { - let mut i: u32 = 0; let skipSize = rankVal[minWeight as usize]; DElt.sequence.0 = u16::to_le_bytes(baseSeq); DElt.nbBits = consumed as u8; DElt.length = 1; - i = 0; + let mut i: u32 = 0; while i < skipSize { DTable[i as usize] = DElt; i = i.wrapping_add(1); @@ -1264,7 +1260,6 @@ unsafe fn HUFv05_readDTableX4(DTable: &mut [u32; 4097], src: &[u8]) -> Result Result> 6 { IS_HUFv05 => { - let mut litSize: size_t = 0; - let mut litCSize: size_t = 0; let mut singleStream = 0; let mut lhSize = (*istart.add(0) as core::ffi::c_int >> 4 & 3) as u32; if src.len() < 5 { return Err(Error::corruption_detected); } + let litSize: size_t; + let litCSize: size_t; match lhSize { 2 => { lhSize = 4; @@ -2061,8 +2056,6 @@ unsafe fn ZSTDv05_decodeLiteralsBlock( Ok(litCSize.wrapping_add(lhSize as size_t)) } IS_PCH => { - let mut litSize_0: size_t = 0; - let mut litCSize_0: size_t = 0; let mut lhSize = (*istart as core::ffi::c_int >> 4 & 3) as u32; if lhSize != 1 { return Err(Error::corruption_detected); @@ -2071,9 +2064,9 @@ unsafe fn ZSTDv05_decodeLiteralsBlock( return Err(Error::dictionary_corrupted); } lhSize = 3; - litSize_0 = (((*istart.add(0) as core::ffi::c_int & 15) << 6) + let litSize_0 = (((*istart.add(0) as core::ffi::c_int & 15) << 6) + (*istart.add(1) as core::ffi::c_int >> 2)) as size_t; - litCSize_0 = (((*istart.add(1) as core::ffi::c_int & 3) << 8) + let litCSize_0 = (((*istart.add(1) as core::ffi::c_int & 3) << 8) + *istart.add(2) as core::ffi::c_int) as size_t; if litCSize_0.wrapping_add(lhSize as size_t) > src.len() { return Err(Error::corruption_detected); @@ -2094,7 +2087,7 @@ unsafe fn ZSTDv05_decodeLiteralsBlock( Ok(litCSize_0.wrapping_add(lhSize as size_t)) } IS_RAW => { - let mut litSize_1: size_t = 0; + let litSize_1: size_t; let mut lhSize_1 = (*istart as core::ffi::c_int >> 4 & 3) as u32; match lhSize_1 { 2 => { @@ -2141,7 +2134,7 @@ unsafe fn ZSTDv05_decodeLiteralsBlock( Ok((lhSize_1 as size_t).wrapping_add(litSize_1)) } IS_RLE => { - let mut litSize_2: size_t = 0; + let litSize_2: size_t; let mut lhSize_2 = (*istart as core::ffi::c_int >> 4 & 3) as u32; match lhSize_2 { 2 => { @@ -2191,13 +2184,6 @@ unsafe fn ZSTDv05_decodeSeqHeaders( let istart = src.as_ptr(); let mut ip = istart; let iend = istart.add(src.len()); - let mut LLtype: u32 = 0; - let mut Offtype: u32 = 0; - let mut MLtype: u32 = 0; - let mut LLlog: core::ffi::c_uint = 0; - let mut Offlog: core::ffi::c_uint = 0; - let mut MLlog: core::ffi::c_uint = 0; - let mut dumpsLength: size_t = 0; if src.len() < MIN_SEQUENCES_SIZE as size_t { return Err(Error::srcSize_wrong); } @@ -2218,9 +2204,10 @@ unsafe fn ZSTDv05_decodeSeqHeaders( if ip >= iend { return Err(Error::srcSize_wrong); } - LLtype = (*ip as core::ffi::c_int >> 6) as u32; - Offtype = (*ip as core::ffi::c_int >> 4 & 3) as u32; - MLtype = (*ip as core::ffi::c_int >> 2 & 3) as u32; + let LLtype = (*ip as core::ffi::c_int >> 6) as u32; + let Offtype = (*ip as core::ffi::c_int >> 4 & 3) as u32; + let MLtype = (*ip as core::ffi::c_int >> 2 & 3) as u32; + let mut dumpsLength: size_t; if *ip as core::ffi::c_int & 2 != 0 { if ip.add(3) > iend { return Err(Error::srcSize_wrong); @@ -2242,16 +2229,13 @@ unsafe fn ZSTDv05_decodeSeqHeaders( return Err(Error::srcSize_wrong); } let mut norm: [i16; 128] = [0; 128]; - let mut headerSize: size_t = 0; match LLtype { 1 => { - LLlog = 0; let fresh41 = ip; ip = ip.add(1); FSEv05_buildDTable_rle(DTableLL, *fresh41); } 0 => { - LLlog = LLbits as core::ffi::c_uint; let _ = FSEv05_buildDTable_raw(DTableLL, LLbits as core::ffi::c_uint); } 2 => { @@ -2261,7 +2245,8 @@ unsafe fn ZSTDv05_decodeSeqHeaders( } 3 => { let mut max = MaxLL as core::ffi::c_uint; - headerSize = FSEv05_readNCount( + let mut LLlog: core::ffi::c_uint = 0; + let headerSize = FSEv05_readNCount( &mut norm, &mut max, &mut LLlog, @@ -2278,7 +2263,6 @@ unsafe fn ZSTDv05_decodeSeqHeaders( } match Offtype { 1 => { - Offlog = 0; if ip > iend.sub(2) { return Err(Error::srcSize_wrong); } @@ -2290,7 +2274,6 @@ unsafe fn ZSTDv05_decodeSeqHeaders( ); } 0 => { - Offlog = Offbits as core::ffi::c_uint; let _ = FSEv05_buildDTable_raw(DTableOffb, Offbits as core::ffi::c_uint); } 2 => { @@ -2299,8 +2282,9 @@ unsafe fn ZSTDv05_decodeSeqHeaders( } } 3 => { + let mut Offlog: core::ffi::c_uint = 0; let mut max = MaxOff as core::ffi::c_uint; - headerSize = FSEv05_readNCount( + let headerSize = FSEv05_readNCount( &mut norm, &mut max, &mut Offlog, @@ -2317,7 +2301,6 @@ unsafe fn ZSTDv05_decodeSeqHeaders( } match MLtype { 1 => { - MLlog = 0; if ip > iend.sub(2) { return Err(Error::srcSize_wrong); } @@ -2326,7 +2309,6 @@ unsafe fn ZSTDv05_decodeSeqHeaders( FSEv05_buildDTable_rle(DTableML, *fresh43); } 0 => { - MLlog = MLbits as core::ffi::c_uint; let _ = FSEv05_buildDTable_raw(DTableML, MLbits as core::ffi::c_uint); } 2 => { @@ -2335,8 +2317,9 @@ unsafe fn ZSTDv05_decodeSeqHeaders( } } 3 => { + let mut MLlog: core::ffi::c_uint = 0; let mut max = MaxML as core::ffi::c_uint; - headerSize = FSEv05_readNCount( + let headerSize = FSEv05_readNCount( &mut norm, &mut max, &mut MLlog, @@ -2354,14 +2337,10 @@ unsafe fn ZSTDv05_decodeSeqHeaders( Ok(ip.offset_from_unsigned(istart)) } unsafe fn ZSTDv05_decodeSequence(seq: &mut seq_t, seqState: &mut seqState_t) { - let mut litLength: size_t = 0; - let mut prevOffset: size_t = 0; - let mut offset: size_t = 0; - let mut matchLength: size_t = 0; let mut dumps = seqState.dumps.as_ptr(); let de = dumps.add(seqState.dumps.len()); - litLength = FSEv05_peakSymbol(&mut seqState.stateLL) as size_t; - prevOffset = if litLength != 0 { + let mut litLength = FSEv05_peakSymbol(&mut seqState.stateLL) as size_t; + let prevOffset = if litLength != 0 { seq.offset } else { seqState.prevOffset @@ -2395,7 +2374,7 @@ unsafe fn ZSTDv05_decodeSequence(seq: &mut seq_t, seqState: &mut seqState_t) { if offsetCode == 0 { nbBits = 0; } - offset = (*offsetPrefix.as_ptr().offset(offsetCode as isize) as size_t) + let mut offset = (*offsetPrefix.as_ptr().offset(offsetCode as isize) as size_t) .wrapping_add(seqState.DStream.read_bits(nbBits)); if MEM_32bits() { seqState.DStream.reload(); @@ -2411,7 +2390,8 @@ unsafe fn ZSTDv05_decodeSequence(seq: &mut seq_t, seqState: &mut seqState_t) { if MEM_32bits() { seqState.DStream.reload(); } - matchLength = FSEv05_decodeSymbol(&mut seqState.stateML, &mut seqState.DStream) as size_t; + let mut matchLength = + FSEv05_decodeSymbol(&mut seqState.stateML, &mut seqState.DStream) as size_t; if matchLength == MaxML as size_t { let add_0 = (if dumps < de { let fresh45 = dumps; @@ -2587,10 +2567,9 @@ unsafe fn ZSTDv05_decompressSequences( offset: REPCODE_STARTVALUE as size_t, }; while seqState.DStream.reload() <= StreamStatus::Completed && nbSeq != 0 { - let mut oneSeqSize: size_t = 0; nbSeq -= 1; ZSTDv05_decodeSequence(&mut sequence, &mut seqState); - oneSeqSize = ZSTDv05_execSequence( + let oneSeqSize = ZSTDv05_execSequence( op, oend, sequence, @@ -2636,11 +2615,10 @@ unsafe fn ZSTDv05_decompressBlock_internal( dstCapacity: size_t, src: Reader<'_>, ) -> Result { - let mut litCSize: size_t = 0; if src.len() >= BLOCKSIZE as size_t { return Err(Error::srcSize_wrong); } - litCSize = ZSTDv05_decodeLiteralsBlock(dctx, src.subslice(..))?; + let litCSize = ZSTDv05_decodeLiteralsBlock(dctx, src.subslice(..))?; ZSTDv05_decompressSequences(dctx, dst, dstCapacity, src.subslice(litCSize..)) } unsafe fn ZSTDv05_decompress_continueDCtx( @@ -2664,19 +2642,17 @@ unsafe fn ZSTDv05_decompress_continueDCtx( 0, size_of::(), ); - let mut frameHeaderSize: size_t = 0; if src.len() < ZSTDv05_frameHeaderSize_min.wrapping_add(ZSTDv05_blockHeaderSize) { return Err(Error::srcSize_wrong); } - frameHeaderSize = + let frameHeaderSize = ZSTDv05_decodeFrameHeader_Part1(dctx, src.subslice(..ZSTDv05_frameHeaderSize_min))?; if src.len() < frameHeaderSize.wrapping_add(ZSTDv05_blockHeaderSize) { return Err(Error::srcSize_wrong); } ip = ip.add(frameHeaderSize); remainingSize = remainingSize.wrapping_sub(frameHeaderSize); - frameHeaderSize = - ZSTDv05_decodeFrameHeader_Part2(dctx, src.subslice(..frameHeaderSize).as_slice())?; + ZSTDv05_decodeFrameHeader_Part2(dctx, src.subslice(..frameHeaderSize).as_slice())?; loop { let cBlockSize = ZSTDv05_getcBlockSize( core::slice::from_raw_parts(ip, iend.offset_from_unsigned(ip)), @@ -3166,11 +3142,10 @@ pub(crate) unsafe fn ZBUFFv05_decompressContinue( let neededInSize = ZSTDv05_nextSrcSizeToDecompress(&mut *zbc.zc); // should always be <= remaining space within inBuff let toLoad = neededInSize.wrapping_sub(zbc.inPos); - let mut loadedSize: size_t = 0; if toLoad > (zbc.inBuffSize).wrapping_sub(zbc.inPos) { return Err(Error::corruption_detected); // should never happen } - loadedSize = ZBUFFv05_limitCopy( + let loadedSize = ZBUFFv05_limitCopy( (zbc.inBuff).add(zbc.inPos) as *mut core::ffi::c_void, toLoad, core::slice::from_raw_parts(ip, iend.offset_from_unsigned(ip)), diff --git a/lib/legacy/zstd_v06.rs b/lib/legacy/zstd_v06.rs index 43edb42f..98ca0719 100644 --- a/lib/legacy/zstd_v06.rs +++ b/lib/legacy/zstd_v06.rs @@ -432,27 +432,22 @@ unsafe fn FSEv06_readNCount( let istart = headerBuffer as *const u8; let iend = istart.add(hbSize); let mut ip = istart; - let mut nbBits: core::ffi::c_int = 0; - let mut remaining: core::ffi::c_int = 0; - let mut threshold: core::ffi::c_int = 0; - let mut bitStream: u32 = 0; - let mut bitCount: core::ffi::c_int = 0; let mut charnum = 0; let mut previous0 = 0; if hbSize < 4 { return Error::srcSize_wrong.to_error_code(); } - bitStream = MEM_readLE32(ip as *const core::ffi::c_void); - nbBits = (bitStream & 0xf as core::ffi::c_int as u32).wrapping_add(FSEv06_MIN_TABLELOG as u32) - as core::ffi::c_int; + let mut bitStream = MEM_readLE32(ip as *const core::ffi::c_void); + let mut nbBits = (bitStream & 0xf as core::ffi::c_int as u32) + .wrapping_add(FSEv06_MIN_TABLELOG as u32) as core::ffi::c_int; if nbBits > FSEv06_TABLELOG_ABSOLUTE_MAX { return Error::tableLog_tooLarge.to_error_code(); } bitStream >>= 4; - bitCount = 4; + let mut bitCount = 4; *tableLogPtr = nbBits as core::ffi::c_uint; - remaining = ((1) << nbBits) + 1; - threshold = (1) << nbBits; + let mut remaining = ((1) << nbBits) + 1; + let mut threshold = (1) << nbBits; nbBits += 1; while remaining > 1 && charnum <= *maxSVPtr { if previous0 != 0 { @@ -492,7 +487,7 @@ unsafe fn FSEv06_readNCount( } } let max = (2 * threshold - 1 - remaining) as core::ffi::c_short; - let mut count: core::ffi::c_short = 0; + let mut count: core::ffi::c_short; if (bitStream & (threshold - 1) as u32) < max as u32 { count = (bitStream & (threshold - 1) as u32) as core::ffi::c_short; bitCount += nbBits - 1; @@ -558,7 +553,6 @@ unsafe fn FSEv06_buildDTable( DTableH.fastMode = 1; let largeLimit = ((1) << tableLog.wrapping_sub(1)) as i16; let mut s: u32 = 0; - s = 0; while s < maxSV1 { if *normalizedCounter.offset(s as isize) as core::ffi::c_int == -(1) { let fresh2 = highThreshold; @@ -587,10 +581,8 @@ unsafe fn FSEv06_buildDTable( .wrapping_add(3); let mut s_0: u32 = 0; let mut position = 0u32; - s_0 = 0; while s_0 < maxSV1 { let mut i: core::ffi::c_int = 0; - i = 0; while i < *normalizedCounter.offset(s_0 as isize) as core::ffi::c_int { (*tableDecode.offset(position as isize)).symbol = s_0 as u8; position = position.wrapping_add(step) & tableMask; @@ -605,7 +597,6 @@ unsafe fn FSEv06_buildDTable( return Error::GENERIC.to_error_code(); } let mut u: u32 = 0; - u = 0; while u < tableSize { let symbol = (*tableDecode.offset(u as isize)).symbol; let fresh3 = &mut (*symbolNext.as_mut_ptr().offset(symbol as isize)); @@ -831,14 +822,12 @@ unsafe fn HUFv06_readStats( src: *const core::ffi::c_void, srcSize: size_t, ) -> size_t { - let mut weightTotal: u32 = 0; let mut ip = src as *const u8; - let mut iSize: size_t = 0; - let mut oSize: size_t = 0; if srcSize == 0 { return Error::srcSize_wrong.to_error_code(); } - iSize = *ip as size_t; + let oSize: size_t; + let mut iSize = *ip as size_t; if iSize >= 128 { if iSize >= 242 { static l: [u32; 14] = [1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128]; @@ -856,7 +845,6 @@ unsafe fn HUFv06_readStats( } ip = ip.add(1); let mut n: u32 = 0; - n = 0; while (n as size_t) < oSize { *huffWeight.offset(n as isize) = (*ip.offset((n / 2) as isize) as core::ffi::c_int >> 4) as u8; @@ -880,9 +868,8 @@ unsafe fn HUFv06_readStats( } } core::ptr::write_bytes(rankStats, 0, (HUFv06_ABSOLUTEMAX_TABLELOG + 1) as size_t); - weightTotal = 0; + let mut weightTotal: u32 = 0; let mut n_0: u32 = 0; - n_0 = 0; while (n_0 as size_t) < oSize { if *huffWeight.offset(n_0 as isize) as core::ffi::c_int >= HUFv06_ABSOLUTEMAX_TABLELOG { return Error::corruption_detected.to_error_code(); @@ -926,13 +913,10 @@ unsafe fn HUFv06_readDTableX2( let mut huffWeight: [u8; 256] = [0; 256]; let mut rankVal: [u32; 17] = [0; 17]; let mut tableLog = 0; - let mut iSize: size_t = 0; let mut nbSymbols = 0; - let mut n: u32 = 0; - let mut nextRankStart: u32 = 0; let dtPtr = DTable.add(1) as *mut core::ffi::c_void; let dt = dtPtr as *mut HUFv06_DEltX2; - iSize = HUFv06_readStats( + let iSize = HUFv06_readStats( huffWeight.as_mut_ptr(), (HUFv06_MAX_SYMBOL_VALUE + 1) as size_t, rankVal.as_mut_ptr(), @@ -948,8 +932,8 @@ unsafe fn HUFv06_readDTableX2( return Error::tableLog_tooLarge.to_error_code(); } *DTable = tableLog as u16; - nextRankStart = 0; - n = 1; + let mut nextRankStart: u32 = 0; + let mut n: u32 = 1; while n < tableLog.wrapping_add(1) { let current = nextRankStart; nextRankStart = nextRankStart @@ -961,11 +945,10 @@ unsafe fn HUFv06_readDTableX2( while n < nbSymbols { let w = *huffWeight.as_mut_ptr().offset(n as isize) as u32; let length = ((1) << w >> 1) as u32; - let mut i: u32 = 0; let mut D = HUFv06_DEltX2 { byte: 0, nbBits: 0 }; D.byte = n as u8; D.nbBits = tableLog.wrapping_add(1).wrapping_sub(w) as u8; - i = *rankVal.as_mut_ptr().offset(w as isize); + let mut i = *rankVal.as_mut_ptr().offset(w as isize); while i < (*rankVal.as_mut_ptr().offset(w as isize)).wrapping_add(length) { *dt.offset(i as isize) = D; i = i.wrapping_add(1); @@ -1102,7 +1085,6 @@ unsafe fn HUFv06_decompress4X2_usingDTable( let dtPtr = DTable as *const core::ffi::c_void; let dt = (dtPtr as *const HUFv06_DEltX2).add(1); let dtLog = *DTable as u32; - let mut errorCode: size_t = 0; let mut bitD1 = BITv06_DStream_t { bitContainer: 0, bitsConsumed: 0, @@ -1130,7 +1112,6 @@ unsafe fn HUFv06_decompress4X2_usingDTable( let length1 = MEM_readLE16(istart as *const core::ffi::c_void) as size_t; let length2 = MEM_readLE16(istart.add(2) as *const core::ffi::c_void) as size_t; let length3 = MEM_readLE16(istart.add(4) as *const core::ffi::c_void) as size_t; - let mut length4: size_t = 0; let istart1 = istart.add(6); let istart2 = istart1.add(length1); let istart3 = istart2.add(length2); @@ -1143,8 +1124,7 @@ unsafe fn HUFv06_decompress4X2_usingDTable( let mut op2 = opStart2; let mut op3 = opStart3; let mut op4 = opStart4; - let mut endSignal: u32 = 0; - length4 = cSrcSize.wrapping_sub( + let length4 = cSrcSize.wrapping_sub( length1 .wrapping_add(length2) .wrapping_add(length3) @@ -1153,23 +1133,23 @@ unsafe fn HUFv06_decompress4X2_usingDTable( if length4 > cSrcSize { return Error::corruption_detected.to_error_code(); } - errorCode = BITv06_initDStream(&mut bitD1, istart1 as *const core::ffi::c_void, length1); + let errorCode = BITv06_initDStream(&mut bitD1, istart1 as *const core::ffi::c_void, length1); if HUFv06_isError(errorCode) != 0 { return errorCode; } - errorCode = BITv06_initDStream(&mut bitD2, istart2 as *const core::ffi::c_void, length2); + let errorCode = BITv06_initDStream(&mut bitD2, istart2 as *const core::ffi::c_void, length2); if HUFv06_isError(errorCode) != 0 { return errorCode; } - errorCode = BITv06_initDStream(&mut bitD3, istart3 as *const core::ffi::c_void, length3); + let errorCode = BITv06_initDStream(&mut bitD3, istart3 as *const core::ffi::c_void, length3); if HUFv06_isError(errorCode) != 0 { return errorCode; } - errorCode = BITv06_initDStream(&mut bitD4, istart4 as *const core::ffi::c_void, length4); + let errorCode = BITv06_initDStream(&mut bitD4, istart4 as *const core::ffi::c_void, length4); if HUFv06_isError(errorCode) != 0 { return errorCode; } - endSignal = BITv06_reloadDStream(&mut bitD1) as core::ffi::c_uint + let mut endSignal = BITv06_reloadDStream(&mut bitD1) as core::ffi::c_uint | BITv06_reloadDStream(&mut bitD2) as core::ffi::c_uint | BITv06_reloadDStream(&mut bitD3) as core::ffi::c_uint | BITv06_reloadDStream(&mut bitD4) as core::ffi::c_uint; @@ -1321,7 +1301,6 @@ unsafe fn HUFv06_fillDTableX4Level2( size_of::<[u32; 17]>(), ); if minWeight > 1 { - let mut i: u32 = 0; let skipSize = *rankVal.as_mut_ptr().offset(minWeight as isize); MEM_writeLE16( &mut DElt.sequence as *mut u16 as *mut core::ffi::c_void, @@ -1329,14 +1308,13 @@ unsafe fn HUFv06_fillDTableX4Level2( ); DElt.nbBits = consumed as u8; DElt.length = 1; - i = 0; + let mut i: u32 = 0; while i < skipSize { *DTable.offset(i as isize) = DElt; i = i.wrapping_add(1); } } let mut s: u32 = 0; - s = 0; while s < sortedListSize { let symbol = (*sortedSymbols.offset(s as isize)).symbol as u32; let weight = (*sortedSymbols.offset(s as isize)).weight as u32; @@ -1377,13 +1355,12 @@ unsafe fn HUFv06_fillDTableX4( let mut rankVal: [u32; 17] = [0; 17]; let scaleLog = nbBitsBaseline.wrapping_sub(targetLog) as core::ffi::c_int; let minBits = nbBitsBaseline.wrapping_sub(maxWeight); - let mut s: u32 = 0; memcpy( rankVal.as_mut_ptr() as *mut core::ffi::c_void, rankValOrigin as *const core::ffi::c_void, size_of::<[u32; 17]>(), ); - s = 0; + let mut s: u32 = 0; while s < sortedListSize { let symbol = (*sortedList.offset(s as isize)).symbol as u16; let weight = (*sortedList.offset(s as isize)).weight as u32; @@ -1391,12 +1368,11 @@ unsafe fn HUFv06_fillDTableX4( let start = *rankVal.as_mut_ptr().offset(weight as isize); let length = ((1) << targetLog.wrapping_sub(nbBits)) as u32; if targetLog.wrapping_sub(nbBits) >= minBits { - let mut sortedRank: u32 = 0; let mut minWeight = nbBits.wrapping_add(scaleLog as u32) as core::ffi::c_int; if minWeight < 1 { minWeight = 1; } - sortedRank = *rankStart.offset(minWeight as isize); + let sortedRank = *rankStart.offset(minWeight as isize); HUFv06_fillDTableX4Level2( DTable.offset(start as isize), targetLog.wrapping_sub(nbBits), @@ -1420,9 +1396,8 @@ unsafe fn HUFv06_fillDTableX4( ); DElt.nbBits = nbBits as u8; DElt.length = 1; - let mut u: u32 = 0; let end = start.wrapping_add(length); - u = start; + let mut u = start; while u < end { *DTable.offset(u as isize) = DElt; u = u.wrapping_add(1); @@ -1448,17 +1423,14 @@ unsafe fn HUFv06_readDTableX4( let rankStart = rankStart0.as_mut_ptr().add(1); let mut rankVal: rankVal_t = [[0; 17]; 16]; let mut tableLog: u32 = 0; - let mut maxW: u32 = 0; - let mut sizeOfSort: u32 = 0; let mut nbSymbols: u32 = 0; let memLog = *DTable; - let mut iSize: size_t = 0; let dtPtr = DTable as *mut core::ffi::c_void; let dt = (dtPtr as *mut HUFv06_DEltX4).add(1); if memLog > HUFv06_ABSOLUTEMAX_TABLELOG as u32 { return Error::tableLog_tooLarge.to_error_code(); } - iSize = HUFv06_readStats( + let iSize = HUFv06_readStats( weightList.as_mut_ptr(), (HUFv06_MAX_SYMBOL_VALUE + 1) as size_t, rankStats.as_mut_ptr(), @@ -1473,13 +1445,12 @@ unsafe fn HUFv06_readDTableX4( if tableLog > memLog { return Error::tableLog_tooLarge.to_error_code(); } - maxW = tableLog; + let mut maxW = tableLog; while *rankStats.as_mut_ptr().offset(maxW as isize) == 0 { maxW = maxW.wrapping_sub(1); } - let mut w: u32 = 0; + let mut w: u32 = 1; let mut nextRankStart = 0u32; - w = 1; while w < maxW.wrapping_add(1) { let current = nextRankStart; nextRankStart = nextRankStart.wrapping_add(*rankStats.as_mut_ptr().offset(w as isize)); @@ -1487,9 +1458,8 @@ unsafe fn HUFv06_readDTableX4( w = w.wrapping_add(1); } *rankStart = nextRankStart; - sizeOfSort = nextRankStart; + let sizeOfSort = nextRankStart; let mut s: u32 = 0; - s = 0; while s < nbSymbols { let w_0 = *weightList.as_mut_ptr().offset(s as isize) as u32; let fresh37 = &mut (*rankStart.offset(w_0 as isize)); @@ -1504,8 +1474,7 @@ unsafe fn HUFv06_readDTableX4( let rankVal0 = (*rankVal.as_mut_ptr()).as_mut_ptr(); let rescale = memLog.wrapping_sub(tableLog).wrapping_sub(1) as core::ffi::c_int; let mut nextRankVal = 0u32; - let mut w_1: u32 = 0; - w_1 = 1; + let mut w_1: u32 = 1; while w_1 < maxW.wrapping_add(1) { let current_0 = nextRankVal; nextRankVal = nextRankVal.wrapping_add( @@ -1515,12 +1484,10 @@ unsafe fn HUFv06_readDTableX4( w_1 = w_1.wrapping_add(1); } let minBits = tableLog.wrapping_add(1).wrapping_sub(maxW); - let mut consumed: u32 = 0; - consumed = minBits; + let mut consumed = minBits; while consumed < memLog.wrapping_sub(minBits).wrapping_add(1) { let rankValPtr = (*rankVal.as_mut_ptr().offset(consumed as isize)).as_mut_ptr(); - let mut w_2: u32 = 0; - w_2 = 1; + let mut w_2: u32 = 1; while w_2 < maxW.wrapping_add(1) { *rankValPtr.offset(w_2 as isize) = *rankVal0.offset(w_2 as isize) >> consumed; w_2 = w_2.wrapping_add(1); @@ -1665,7 +1632,6 @@ unsafe fn HUFv06_decompress4X4_usingDTable( let dtPtr = DTable as *const core::ffi::c_void; let dt = (dtPtr as *const HUFv06_DEltX4).add(1); let dtLog = *DTable; - let mut errorCode: size_t = 0; let mut bitD1 = BITv06_DStream_t { bitContainer: 0, bitsConsumed: 0, @@ -1693,7 +1659,6 @@ unsafe fn HUFv06_decompress4X4_usingDTable( let length1 = MEM_readLE16(istart as *const core::ffi::c_void) as size_t; let length2 = MEM_readLE16(istart.add(2) as *const core::ffi::c_void) as size_t; let length3 = MEM_readLE16(istart.add(4) as *const core::ffi::c_void) as size_t; - let mut length4: size_t = 0; let istart1 = istart.add(6); let istart2 = istart1.add(length1); let istart3 = istart2.add(length2); @@ -1706,8 +1671,7 @@ unsafe fn HUFv06_decompress4X4_usingDTable( let mut op2 = opStart2; let mut op3 = opStart3; let mut op4 = opStart4; - let mut endSignal: u32 = 0; - length4 = cSrcSize.wrapping_sub( + let length4 = cSrcSize.wrapping_sub( length1 .wrapping_add(length2) .wrapping_add(length3) @@ -1716,23 +1680,23 @@ unsafe fn HUFv06_decompress4X4_usingDTable( if length4 > cSrcSize { return Error::corruption_detected.to_error_code(); } - errorCode = BITv06_initDStream(&mut bitD1, istart1 as *const core::ffi::c_void, length1); + let errorCode = BITv06_initDStream(&mut bitD1, istart1 as *const core::ffi::c_void, length1); if HUFv06_isError(errorCode) != 0 { return errorCode; } - errorCode = BITv06_initDStream(&mut bitD2, istart2 as *const core::ffi::c_void, length2); + let errorCode = BITv06_initDStream(&mut bitD2, istart2 as *const core::ffi::c_void, length2); if HUFv06_isError(errorCode) != 0 { return errorCode; } - errorCode = BITv06_initDStream(&mut bitD3, istart3 as *const core::ffi::c_void, length3); + let errorCode = BITv06_initDStream(&mut bitD3, istart3 as *const core::ffi::c_void, length3); if HUFv06_isError(errorCode) != 0 { return errorCode; } - errorCode = BITv06_initDStream(&mut bitD4, istart4 as *const core::ffi::c_void, length4); + let errorCode = BITv06_initDStream(&mut bitD4, istart4 as *const core::ffi::c_void, length4); if HUFv06_isError(errorCode) != 0 { return errorCode; } - endSignal = BITv06_reloadDStream(&mut bitD1) as core::ffi::c_uint + let mut endSignal = BITv06_reloadDStream(&mut bitD1) as core::ffi::c_uint | BITv06_reloadDStream(&mut bitD2) as core::ffi::c_uint | BITv06_reloadDStream(&mut bitD3) as core::ffi::c_uint | BITv06_reloadDStream(&mut bitD4) as core::ffi::c_uint; @@ -2264,7 +2228,6 @@ unsafe fn HUFv06_decompress( let Q = (cSrcSize * 16 / dstSize) as u32; let D256 = (dstSize >> 8) as u32; let mut n: u32 = 0; - n = 0; while n < 3 { *Dtime.as_mut_ptr().offset(n as isize) = ((*(*algoTime.as_ptr().offset(Q as isize)) .as_ptr() @@ -2391,12 +2354,11 @@ unsafe fn ZSTDv06_getcBlockSize( bpPtr: *mut blockProperties_t, ) -> size_t { let in_0 = src as *const u8; - let mut cSize: u32 = 0; if srcSize < ZSTDv06_blockHeaderSize { return Error::srcSize_wrong.to_error_code(); } (*bpPtr).blockType = (*in_0 as core::ffi::c_int >> 6) as blockType_t; - cSize = (*in_0.add(2) as core::ffi::c_int + let cSize = (*in_0.add(2) as core::ffi::c_int + ((*in_0.add(1) as core::ffi::c_int) << 8) + ((*in_0 as core::ffi::c_int & 7) << 16)) as u32; (*bpPtr).origSize = if (*bpPtr).blockType as core::ffi::c_uint @@ -2440,8 +2402,8 @@ unsafe fn ZSTDv06_decodeLiteralsBlock( } match *istart as core::ffi::c_int >> 6 { IS_HUF => { - let mut litSize: size_t = 0; - let mut litCSize: size_t = 0; + let litSize: size_t; + let litCSize: size_t; let mut singleStream = 0; let mut lhSize = (*istart as core::ffi::c_int >> 4 & 3) as u32; if srcSize < 5 { @@ -2514,8 +2476,6 @@ unsafe fn ZSTDv06_decodeLiteralsBlock( litCSize.wrapping_add(lhSize as size_t) } IS_PCH => { - let mut litSize_0: size_t = 0; - let mut litCSize_0: size_t = 0; let mut lhSize_0 = (*istart as core::ffi::c_int >> 4 & 3) as u32; if lhSize_0 != 1 { return Error::corruption_detected.to_error_code(); @@ -2524,9 +2484,9 @@ unsafe fn ZSTDv06_decodeLiteralsBlock( return Error::dictionary_corrupted.to_error_code(); } lhSize_0 = 3; - litSize_0 = (((*istart as core::ffi::c_int & 15) << 6) + let litSize_0 = (((*istart as core::ffi::c_int & 15) << 6) + (*istart.add(1) as core::ffi::c_int >> 2)) as size_t; - litCSize_0 = (((*istart.add(1) as core::ffi::c_int & 3) << 8) + let litCSize_0 = (((*istart.add(1) as core::ffi::c_int & 3) << 8) + *istart.add(2) as core::ffi::c_int) as size_t; if litCSize_0.wrapping_add(lhSize_0 as size_t) > srcSize { return Error::corruption_detected.to_error_code(); @@ -2551,7 +2511,7 @@ unsafe fn ZSTDv06_decodeLiteralsBlock( litCSize_0.wrapping_add(lhSize_0 as size_t) } IS_RAW => { - let mut litSize_1: size_t = 0; + let litSize_1: size_t; let mut lhSize_1 = (*istart as core::ffi::c_int >> 4 & 3) as u32; match lhSize_1 { 2 => { @@ -2598,7 +2558,7 @@ unsafe fn ZSTDv06_decodeLiteralsBlock( (lhSize_1 as size_t).wrapping_add(litSize_1) } IS_RLE => { - let mut litSize_2: size_t = 0; + let litSize_2: size_t; let mut lhSize_2 = (*istart as core::ffi::c_int >> 4 & 3) as u32; match lhSize_2 { 2 => { @@ -2910,7 +2870,7 @@ unsafe fn ZSTDv06_decodeSequence(seq: *mut seq_t, seqState: *mut seqState_t) { 1, 1, ]; - let mut offset: size_t = 0; + let mut offset: size_t; if ofCode == 0 { offset = 0; } else { @@ -3151,7 +3111,6 @@ unsafe fn ZSTDv06_decompressSequences( ); sequence.offset = REPCODE_STARTVALUE as size_t; let mut i: u32 = 0; - i = 0; while i < ZSTDv06_REP_INIT as u32 { *(seqState.prevOffset).as_mut_ptr().offset(i as isize) = REPCODE_STARTVALUE as size_t; i = i.wrapping_add(1); @@ -3469,20 +3428,13 @@ unsafe fn ZSTDv06_decompressContinue( return 0; } 3 => { - let mut rSize: size_t = 0; - match (*dctx).bType as core::ffi::c_uint { - 0 => { - rSize = ZSTDv06_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize); - } - 1 => { - rSize = ZSTDv06_copyRawBlock(dst, dstCapacity, src, srcSize); - } + let rSize = match (*dctx).bType as core::ffi::c_uint { + 0 => ZSTDv06_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize), + 1 => ZSTDv06_copyRawBlock(dst, dstCapacity, src, srcSize), 2 => return Error::GENERIC.to_error_code(), - 3 => { - rSize = 0; - } + 3 => 0, _ => return Error::GENERIC.to_error_code(), - } + }; (*dctx).stage = ZSTDds_decodeBlockHeader; (*dctx).expected = ZSTDv06_blockHeaderSize; if ERR_isError(rSize) { @@ -3494,7 +3446,6 @@ unsafe fn ZSTDv06_decompressContinue( } _ => return Error::GENERIC.to_error_code(), } - let mut result: size_t = 0; memcpy( ((*dctx).headerBuffer) .as_mut_ptr() @@ -3502,7 +3453,7 @@ unsafe fn ZSTDv06_decompressContinue( src, (*dctx).expected, ); - result = ZSTDv06_decodeFrameHeader( + let result = ZSTDv06_decodeFrameHeader( dctx, ((*dctx).headerBuffer).as_mut_ptr() as *const core::ffi::c_void, (*dctx).headerSize, @@ -3534,11 +3485,7 @@ unsafe fn ZSTDv06_loadEntropy( mut dict: *const core::ffi::c_void, mut dictSize: size_t, ) -> size_t { - let mut hSize: size_t = 0; - let mut offcodeHeaderSize: size_t = 0; - let mut matchlengthHeaderSize: size_t = 0; - let mut litlengthHeaderSize: size_t = 0; - hSize = HUFv06_readDTableX4(((*dctx).hufTableX4).as_mut_ptr(), dict, dictSize); + let hSize = HUFv06_readDTableX4(((*dctx).hufTableX4).as_mut_ptr(), dict, dictSize); if ERR_isError(hSize) { return Error::dictionary_corrupted.to_error_code(); } @@ -3547,7 +3494,7 @@ unsafe fn ZSTDv06_loadEntropy( let mut offcodeNCount: [core::ffi::c_short; 29] = [0; 29]; let mut offcodeMaxValue = MaxOff as u32; let mut offcodeLog: u32 = 0; - offcodeHeaderSize = FSEv06_readNCount( + let offcodeHeaderSize = FSEv06_readNCount( offcodeNCount.as_mut_ptr(), &mut offcodeMaxValue, &mut offcodeLog, @@ -3574,7 +3521,7 @@ unsafe fn ZSTDv06_loadEntropy( let mut matchlengthNCount: [core::ffi::c_short; 53] = [0; 53]; let mut matchlengthMaxValue = MaxML as core::ffi::c_uint; let mut matchlengthLog: core::ffi::c_uint = 0; - matchlengthHeaderSize = FSEv06_readNCount( + let matchlengthHeaderSize = FSEv06_readNCount( matchlengthNCount.as_mut_ptr(), &mut matchlengthMaxValue, &mut matchlengthLog, @@ -3602,7 +3549,7 @@ unsafe fn ZSTDv06_loadEntropy( let mut litlengthNCount: [core::ffi::c_short; 36] = [0; 36]; let mut litlengthMaxValue = MaxLL as core::ffi::c_uint; let mut litlengthLog: core::ffi::c_uint = 0; - litlengthHeaderSize = FSEv06_readNCount( + let litlengthHeaderSize = FSEv06_readNCount( litlengthNCount.as_mut_ptr(), &mut litlengthMaxValue, &mut litlengthLog, @@ -3635,7 +3582,6 @@ unsafe fn ZSTDv06_decompress_insertDictionary( mut dict: *const core::ffi::c_void, mut dictSize: size_t, ) -> size_t { - let mut eSize: size_t = 0; let magic = MEM_readLE32(dict); if magic != ZSTDv06_DICT_MAGIC { ZSTDv06_refDictContent(dctx, dict, dictSize); @@ -3643,7 +3589,7 @@ unsafe fn ZSTDv06_decompress_insertDictionary( } dict = (dict as *const core::ffi::c_char).add(4) as *const core::ffi::c_void; dictSize = dictSize.wrapping_sub(4); - eSize = ZSTDv06_loadEntropy(dctx, dict, dictSize); + let eSize = ZSTDv06_loadEntropy(dctx, dict, dictSize); if ERR_isError(eSize) { return Error::dictionary_corrupted.to_error_code(); } @@ -3901,11 +3847,10 @@ pub(crate) unsafe fn ZBUFFv06_decompressContinue( let neededInSize_0 = ZSTDv06_nextSrcSizeToDecompress((*zbd).zd); // should always be <= remaining space within inBuff let toLoad_0 = neededInSize_0.wrapping_sub((*zbd).inPos); - let mut loadedSize: size_t = 0; if toLoad_0 > ((*zbd).inBuffSize).wrapping_sub((*zbd).inPos) { return Error::corruption_detected.to_error_code(); } - loadedSize = ZBUFFv06_limitCopy( + let loadedSize = ZBUFFv06_limitCopy( ((*zbd).inBuff).add((*zbd).inPos) as *mut core::ffi::c_void, toLoad_0, ip as *const core::ffi::c_void, diff --git a/lib/legacy/zstd_v07.rs b/lib/legacy/zstd_v07.rs index 1bd031be..506643dc 100644 --- a/lib/legacy/zstd_v07.rs +++ b/lib/legacy/zstd_v07.rs @@ -482,7 +482,7 @@ unsafe fn FSEv07_readNCount( } } let max = (2 * threshold - 1 - remaining) as core::ffi::c_short; - let mut count: core::ffi::c_short = 0; + let mut count: core::ffi::c_short; if (bitStream & (threshold - 1) as u32) < max as u32 { count = (bitStream & (threshold - 1) as u32) as core::ffi::c_short; bitCount += nbBits - 1; @@ -530,14 +530,12 @@ fn HUFv07_readStats( tableLogPtr: &mut u32, src: &[u8], ) -> Result { - let mut weightTotal: u32 = 0; let mut ip = src; - let mut iSize: usize = 0; - let mut oSize: usize = 0; if src.is_empty() { return Err(Error::srcSize_wrong); } - iSize = ip[0] as usize; + let mut iSize = ip[0] as usize; + let oSize: usize; if iSize >= 128 { if iSize >= 242 { static l: [u32; 14] = [1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128]; @@ -571,7 +569,7 @@ fn HUFv07_readStats( )?; } rankStats.fill(0); - weightTotal = 0; + let mut weightTotal: u32 = 0; let mut n_0: usize = 0; while n_0 < oSize { if huffWeight[n_0] as usize >= HUFv07_TABLELOG_ABSOLUTEMAX { @@ -664,7 +662,6 @@ fn FSEv07_buildDTable( return Err(Error::GENERIC); } let mut u: u32 = 0; - u = 0; while u < tableSize { let symbol = tableDecode[u as usize].symbol; let nextState = symbolNext[usize::from(symbol)]; @@ -814,8 +811,7 @@ fn HUFv07_readDTableX2(DTable: &mut HUFv07_DTable, src: &[u8]) -> Result= minBits { - let mut sortedRank: u32 = 0; let mut minWeight = nbBits.wrapping_add(scaleLog as u32) as core::ffi::c_int; if minWeight < 1 { minWeight = 1; } - sortedRank = rankStart[minWeight as usize]; + let sortedRank = rankStart[minWeight as usize]; HUFv07_fillDTableX4Level2( &mut DTable[start as usize..], targetLog.wrapping_sub(nbBits), @@ -1120,16 +1115,14 @@ fn HUFv07_readDTableX4(DTable: &mut HUFv07_DTable, src: &[u8]) -> Result HUFv07_TABLELOG_ABSOLUTEMAX as u32 { return Err(Error::tableLog_tooLarge); } - iSize = HUFv07_readStats( + let iSize = HUFv07_readStats( &mut weightList, &mut rankStats, &mut nbSymbols, @@ -1150,7 +1143,7 @@ fn HUFv07_readDTableX4(DTable: &mut HUFv07_DTable, src: &[u8]) -> Result *mut ZSTDv07_DCtx { - let mut dctx = core::ptr::null_mut::(); - dctx = calloc(1, size_of::()) as *mut ZSTDv07_DCtx; + let dctx = calloc(1, size_of::()) as *mut ZSTDv07_DCtx; if dctx.is_null() { return core::ptr::null_mut(); } @@ -1785,14 +1777,13 @@ unsafe fn ZSTDv07_decodeFrameHeader(dctx: *mut ZSTDv07_DCtx, src: &[u8]) -> Resu result } fn ZSTDv07_getcBlockSize(src: Reader<'_>, bpPtr: &mut blockProperties_t) -> Result { - let mut cSize: u32 = 0; if src.len() < ZSTDv07_blockHeaderSize { return Err(Error::srcSize_wrong); } let src = src.subslice(..ZSTDv07_blockHeaderSize); let src = src.as_slice(); bpPtr.blockType = (src[0] >> 6) as blockType_t; - cSize = u32::from(src[2]) + (u32::from(src[1]) << 8) + (u32::from(src[0] & 7) << 16); + let cSize = u32::from(src[2]) + (u32::from(src[1]) << 8) + (u32::from(src[0] & 7) << 16); bpPtr.origSize = if bpPtr.blockType == bt_rle { cSize } else { 0 }; if bpPtr.blockType == bt_end { return Ok(0); @@ -1821,8 +1812,8 @@ unsafe fn ZSTDv07_decodeLiteralsBlock(dctx: &mut ZSTDv07_DCtx, src: &[u8]) -> Re } match (src[0] >> 6) as litBlockType_t { 0 => { - let mut litSize: usize = 0; - let mut litCSize: usize = 0; + let litSize: usize; + let litCSize: usize; let mut singleStream = 0; let mut lhSize = usize::from((src[0] >> 4) & 3); if src.len() < 5 { @@ -1881,8 +1872,6 @@ unsafe fn ZSTDv07_decodeLiteralsBlock(dctx: &mut ZSTDv07_DCtx, src: &[u8]) -> Re Ok(litCSize.wrapping_add(lhSize)) } 1 => { - let mut litSize: usize = 0; - let mut litCSize: usize = 0; let mut lhSize = usize::from((src[0] >> 4) & 3); if lhSize != 1 { return Err(Error::corruption_detected); @@ -1891,8 +1880,8 @@ unsafe fn ZSTDv07_decodeLiteralsBlock(dctx: &mut ZSTDv07_DCtx, src: &[u8]) -> Re return Err(Error::dictionary_corrupted); } lhSize = 3; - litSize = ((usize::from(src[0]) & 15) << 6) + (usize::from(src[1]) >> 2); - litCSize = ((usize::from(src[1]) & 3) << 8) + usize::from(src[2]); + let litSize = ((usize::from(src[0]) & 15) << 6) + (usize::from(src[1]) >> 2); + let litCSize = ((usize::from(src[1]) & 3) << 8) + usize::from(src[2]); if litCSize.wrapping_add(lhSize) > src.len() { return Err(Error::corruption_detected); } @@ -1908,7 +1897,7 @@ unsafe fn ZSTDv07_decodeLiteralsBlock(dctx: &mut ZSTDv07_DCtx, src: &[u8]) -> Re Ok(litCSize + lhSize) } 2 => { - let mut litSize: usize = 0; + let litSize: usize; let mut lhSize = usize::from((src[0] >> 4) & 3); match lhSize { 2 => { @@ -1944,7 +1933,7 @@ unsafe fn ZSTDv07_decodeLiteralsBlock(dctx: &mut ZSTDv07_DCtx, src: &[u8]) -> Re Ok(lhSize + litSize) } 3 => { - let mut litSize: usize = 0; + let litSize: usize; let mut lhSize = usize::from((src[0] >> 4) & 3); match lhSize { 2 => { @@ -2128,7 +2117,7 @@ fn ZSTDv07_decodeSequence(seqState: &mut seqState_t) -> seq_t { 0x7ffd, 0xfffd, 0x1fffd, 0x3fffd, 0x7fffd, 0xffffd, 0x1ffffd, 0x3ffffd, 0x7ffffd, 0xfffffd, 0x1fffffd, 0x3fffffd, 0x7fffffd, 0xffffffd, ]; - let mut offset: usize = 0; + let mut offset: usize; if ofCode == 0 { offset = 0; } else { @@ -2762,8 +2751,7 @@ unsafe fn ZSTDv07_decompressBegin_usingDict( Ok(()) } pub(crate) unsafe fn ZBUFFv07_createDCtx() -> *mut ZBUFFv07_DCtx { - let mut zbd = core::ptr::null_mut::(); - zbd = calloc(1, size_of::()) as *mut ZBUFFv07_DCtx; + let zbd = calloc(1, size_of::()) as *mut ZBUFFv07_DCtx; if zbd.is_null() { return core::ptr::null_mut(); } @@ -2975,11 +2963,10 @@ pub(crate) unsafe fn ZBUFFv07_decompressContinue( let neededInSize_0 = ZSTDv07_nextSrcSizeToDecompress(&*zbd.zd); // should always be <= remaining space within inBuff let toLoad = neededInSize_0.wrapping_sub(zbd.inPos); - let mut loadedSize: usize = 0; if toLoad > zbd.inBuffSize.wrapping_sub(zbd.inPos) { return Err(Error::corruption_detected); // should never happen } - loadedSize = ZBUFFv07_limitCopy( + let loadedSize = ZBUFFv07_limitCopy( zbd.inBuff.add(zbd.inPos) as *mut core::ffi::c_void, toLoad, ip as *const core::ffi::c_void, diff --git a/programs/benchfn.rs b/programs/benchfn.rs index 08ad4908..d7ebc581 100644 --- a/programs/benchfn.rs +++ b/programs/benchfn.rs @@ -112,21 +112,18 @@ pub unsafe fn BMK_benchFunction( ) -> BMK_runOutcome_t { nbLoops = nbLoops.wrapping_add((nbLoops == 0) as core::ffi::c_int as core::ffi::c_uint); let mut i: size_t = 0; - i = 0; while i < p.blockCount { core::ptr::write_bytes(*(p.dstBuffers).add(i), 0xe5, *(p.dstCapacities).add(i)); i = i.wrapping_add(1); } let mut dstSize = 0 as size_t; let clockStart = UTIL_getTime(); - let mut loopNb: core::ffi::c_uint = 0; - let mut blockNb: core::ffi::c_uint = 0; if (p.initFn).is_some() { (p.initFn).unwrap_unchecked()(p.initPayload); } - loopNb = 0; + let mut loopNb: core::ffi::c_uint = 0; while loopNb < nbLoops { - blockNb = 0; + let mut blockNb: core::ffi::c_uint = 0; while (blockNb as size_t) < p.blockCount { let res = (p.benchFn).unwrap_unchecked()( *(p.srcBuffers).offset(blockNb as isize), diff --git a/programs/benchzstd.rs b/programs/benchzstd.rs index 4b31da1f..ac2e7df2 100644 --- a/programs/benchzstd.rs +++ b/programs/benchzstd.rs @@ -135,7 +135,6 @@ unsafe fn formatString_u( let valueSize = uintSize(value); let mut written = 0; let mut i: core::ffi::c_int = 0; - i = 0; while *formatString.offset(i as isize) as core::ffi::c_int != '\0' as i32 && written < buffer_size.wrapping_sub(1) { @@ -807,7 +806,6 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( let loadedCompressedSize = srcSize; let mut cSize = 0; let mut ratio = 0.0f64; - let mut nbChunks = 0; assert!(!cctx.is_null()); assert!(!dctx.is_null()); ptr::write_bytes( @@ -822,7 +820,6 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( let mut srcPtr = srcBuffer as *const core::ffi::c_char; let mut totalDSize64 = 0u64; let mut fileNb: u32 = 0; - fileNb = 0; while fileNb < nbFiles { let fSize64 = ZSTD_findDecompressedSize( srcPtr as *const core::ffi::c_void, @@ -981,8 +978,6 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( let mut resPtr = *resultBufferPtr as *mut core::ffi::c_char; let mut fileNb_0: u32 = 0; let mut chunkID: u32 = 0; - chunkID = 0; - fileNb_0 = 0; while fileNb_0 < nbFiles { let mut reing = *fileSizes.offset(fileNb_0 as isize); let nbChunksforThisFile = if (*adv).mode as core::ffi::c_uint @@ -1034,7 +1029,7 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( } fileNb_0 = fileNb_0.wrapping_add(1); } - nbChunks = chunkID; + let nbChunks = chunkID; if (*adv).mode as core::ffi::c_uint == BMK_decodeOnly as core::ffi::c_int as core::ffi::c_uint { memcpy(compressedBuffer, srcBuffer, loadedCompressedSize); } else { @@ -1095,17 +1090,17 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( blockResults: core::ptr::null_mut::(), }; let mut cctxprep = BMK_initCCtxArgs { - cctx: core::ptr::null_mut::(), - dictBuffer: core::ptr::null::(), - dictBufferSize: 0, - cLevel: 0, - comprParams: core::ptr::null::(), - adv: core::ptr::null::(), + cctx, + dictBuffer, + dictBufferSize, + cLevel, + comprParams, + adv, }; let mut dctxprep = BMK_initDCtxArgs { - dctx: core::ptr::null_mut::(), - dictBuffer: core::ptr::null::(), - dictBufferSize: 0, + dctx, + dictBuffer, + dictBufferSize, }; cbp.benchFn = Some( local_defaultCompress @@ -1127,12 +1122,6 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( cbp.dstBuffers = cPtrs; cbp.dstCapacities = cCapacities; cbp.blockResults = cSizes; - cctxprep.cctx = cctx; - cctxprep.dictBuffer = dictBuffer; - cctxprep.dictBufferSize = dictBufferSize; - cctxprep.cLevel = cLevel; - cctxprep.comprParams = comprParams; - cctxprep.adv = adv; dbp.benchFn = Some( local_defaultDecompress as unsafe fn( @@ -1153,9 +1142,6 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( dbp.dstBuffers = resPtrs; dbp.dstCapacities = resSizes; dbp.blockResults = core::ptr::null_mut(); - dctxprep.dctx = dctx; - dctxprep.dictBuffer = dictBuffer; - dctxprep.dictBufferSize = dictBufferSize; if displayLevel >= 2 { fprintf( stdout, @@ -1326,7 +1312,6 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( if (*adv).mode as core::ffi::c_uint == BMK_both as core::ffi::c_int as core::ffi::c_uint && crcOrig != crcCheck { - let mut u: size_t = 0; fprintf( stderr, b"!!! WARNING !!! %14s : Invalid Checksum : %x != %x \n\0" as *const u8 @@ -1336,14 +1321,11 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( crcCheck as core::ffi::c_uint, ); fflush(core::ptr::null_mut()); - u = 0; + let mut u: size_t = 0; while u < srcSize { if *(srcBuffer as *const u8).add(u) as core::ffi::c_int != *resultBuffer.add(u) as core::ffi::c_int { - let mut segNb: core::ffi::c_uint = 0; - let mut bNb: core::ffi::c_uint = 0; - let mut pos: core::ffi::c_uint = 0; let mut bacc = 0 as size_t; fprintf( stderr, @@ -1351,7 +1333,7 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( u as core::ffi::c_uint, ); fflush(core::ptr::null_mut()); - segNb = 0; + let mut segNb: core::ffi::c_uint = 0; while segNb < nbChunks { if bacc.wrapping_add(*srcSizes.offset(segNb as isize)) > u { break; @@ -1359,8 +1341,8 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( bacc = bacc.wrapping_add(*srcSizes.offset(segNb as isize)); segNb = segNb.wrapping_add(1); } - pos = u.wrapping_sub(bacc) as u32; - bNb = pos.wrapping_div((128 * ((1) << 10)) as core::ffi::c_uint); + let pos = u.wrapping_sub(bacc) as u32; + let bNb = pos.wrapping_div((128 * ((1) << 10)) as core::ffi::c_uint); fprintf( stderr, b"(sample %u, chunk %u, pos %u) \n\0" as *const u8 as *const core::ffi::c_char, @@ -1370,13 +1352,12 @@ unsafe fn BMK_benchMemAdvancedNoAlloc( ); fflush(core::ptr::null_mut()); let lowest = if u > 5 { 5 } else { u }; - let mut n: size_t = 0; fprintf( stderr, b"origin: \0" as *const u8 as *const core::ffi::c_char, ); fflush(core::ptr::null_mut()); - n = lowest; + let mut n: size_t = lowest; while n > 0 { fprintf( stderr, @@ -1732,7 +1713,6 @@ unsafe fn BMK_benchCLevels( mut displayName: *const core::ffi::c_char, adv: *const BMK_advancedParams_t, ) -> core::ffi::c_int { - let mut level: core::ffi::c_int = 0; let mut pch: *const core::ffi::c_char = strrchr(displayName, '\\' as i32); if pch.is_null() { pch = strrchr(displayName, '/' as i32); @@ -1784,7 +1764,7 @@ unsafe fn BMK_benchCLevels( ); fflush(core::ptr::null_mut()); } - level = startCLevel; + let mut level = startCLevel; while level <= endCLevel { let res = BMK_benchMemAdvanced( srcBuffer, @@ -1866,7 +1846,7 @@ pub unsafe fn BMK_syntheticTest( } unsafe fn BMK_findMaxMem(mut requiredMem: u64) -> size_t { let step = (64 * ((1) << 20)) as size_t; - let mut testmem = core::ptr::null_mut(); + let mut testmem; requiredMem = (requiredMem >> 26).wrapping_add(1) << 26; requiredMem = requiredMem.wrapping_add(step as u64); if requiredMem > maxMemory as u64 { @@ -1893,7 +1873,6 @@ unsafe fn BMK_loadFiles( let mut pos = 0; let mut totalSize = 0 as size_t; let mut n: core::ffi::c_uint = 0; - n = 0; while n < nbFiles { let filename = *fileNamesTable.offset(n as isize); let mut fileSize = UTIL_getFileSize(filename); @@ -2027,10 +2006,8 @@ pub unsafe fn BMK_benchFilesAdvanced( adv: *const BMK_advancedParams_t, ) -> core::ffi::c_int { let mut srcBuffer = core::ptr::null_mut(); - let mut benchedSize: size_t = 0; let mut dictBuffer = core::ptr::null_mut(); let mut dictBufferSize = 0; - let mut fileSizes = core::ptr::null_mut(); let mut res = 1; let totalSizeToLoad = UTIL_getTotalFileSize(fileNamesTable, nbFiles); @@ -2055,7 +2032,7 @@ pub unsafe fn BMK_benchFilesAdvanced( return 15; } - fileSizes = calloc(nbFiles as size_t, size_of::()) as *mut size_t; + let fileSizes = calloc(nbFiles as size_t, size_of::()) as *mut size_t; if fileSizes.is_null() { if displayLevel >= 1 { eprintln!("not enough memory for fileSizes"); @@ -2118,7 +2095,7 @@ pub unsafe fn BMK_benchFilesAdvanced( } // Memory allocation & restrictions - benchedSize = BMK_findMaxMem(totalSizeToLoad * 3) / 3; + let mut benchedSize = BMK_findMaxMem(totalSizeToLoad * 3) / 3; if benchedSize > totalSizeToLoad as size_t { benchedSize = totalSizeToLoad as size_t; } diff --git a/programs/datagen.rs b/programs/datagen.rs index 30faa409..9b23f83b 100644 --- a/programs/datagen.rs +++ b/programs/datagen.rs @@ -36,7 +36,6 @@ unsafe fn RDG_fillLiteralDistrib(ldt: *mut u8, ld: fixedPoint_24_8) { '0' as i32 }) as u8; let mut u: u32 = 0; - u = 0; while u < LTSIZE as u32 { let weight = (((LTSIZE as u32).wrapping_sub(u) * ld) >> 8).wrapping_add(1); let end = if u.wrapping_add(weight) < ((1) << 13) as u32 { diff --git a/programs/dibio.rs b/programs/dibio.rs index 3693b826..426c8022 100644 --- a/programs/dibio.rs +++ b/programs/dibio.rs @@ -65,7 +65,6 @@ unsafe fn DiB_loadFiles( let mut fileIndex = 0 as core::ffi::c_int; let mut f = core::ptr::null_mut(); while nbSamplesLoaded < sstSize && fileIndex < nbFiles { - let mut fileDataLoaded: size_t = 0; let fileSize = DiB_getFileSize(*fileNamesTable.offset(fileIndex as isize)); if fileSize <= 0 { fileIndex += 1; @@ -101,7 +100,7 @@ unsafe fn DiB_loadFiles( fflush(stderr); } } - fileDataLoaded = if targetChunkSize > 0 { + let mut fileDataLoaded = if targetChunkSize > 0 { (if fileSize < targetChunkSize as i64 { fileSize } else { @@ -214,11 +213,10 @@ unsafe fn DiB_rand(src: *mut u32) -> u32 { } unsafe fn DiB_shuffle(fileNamesTable: *mut *const core::ffi::c_char, nbFiles: core::ffi::c_uint) { let mut seed = 0xfd2fb528 as core::ffi::c_uint; - let mut i: core::ffi::c_uint = 0; if nbFiles == 0 { return; } - i = nbFiles.wrapping_sub(1); + let mut i = nbFiles.wrapping_sub(1); while i > 0 { let j = (DiB_rand(&raw mut seed)).wrapping_rem(i.wrapping_add(1)); let tmp = *fileNamesTable.offset(j as isize); @@ -249,7 +247,6 @@ unsafe fn DiB_fillNoise(buffer: *mut core::ffi::c_void, length: size_t) { let prime2 = 2246822519 as core::ffi::c_uint; let mut acc = prime1; let mut p = 0; - p = 0; while p < length { acc = acc.wrapping_mul(prime2); *(buffer as *mut core::ffi::c_uchar).add(p) = (acc >> 21) as core::ffi::c_uchar; @@ -323,7 +320,6 @@ unsafe fn DiB_fileStats( }; let mut n: core::ffi::c_int = 0; ptr::write_bytes(&raw mut fs as *mut u8, 0, size_of::()); - n = 0; while n < nbFiles { let fileSize = DiB_getFileSize(*fileNamesTable.offset(n as isize)); if fileSize == 0 { @@ -388,15 +384,6 @@ pub unsafe fn DiB_trainFromFiles( optimize: core::ffi::c_int, memLimit: core::ffi::c_uint, ) -> core::ffi::c_int { - let mut fs = fileStats { - totalSizeToLoad: 0, - nbSamples: 0, - oneSampleTooLarge: 0, - }; - let mut sampleSizes = core::ptr::null_mut::(); - let mut nbSamplesLoaded: core::ffi::c_int = 0; - let mut loadedSize: size_t = 0; - let mut srcBuffer = core::ptr::null_mut::(); let dictBuffer = malloc(maxDictSize); let mut result = 0; let displayLevel = (if !params.is_null() { @@ -415,7 +402,7 @@ pub unsafe fn DiB_trainFromFiles( ); } DiB_shuffle(fileNamesTable, nbFiles as core::ffi::c_uint); - fs = DiB_fileStats(fileNamesTable, nbFiles, chunkSize, displayLevel); + let fs = DiB_fileStats(fileNamesTable, nbFiles, chunkSize, displayLevel); let memMult = if !params.is_null() { MEMMULT } else if !coverParams.is_null() { @@ -425,12 +412,12 @@ pub unsafe fn DiB_trainFromFiles( }; let maxMem = DiB_findMaxMem((fs.totalSizeToLoad * memMult as i64) as core::ffi::c_ulonglong) / memMult as size_t; - loadedSize = (if (if (maxMem as i64) < fs.totalSizeToLoad { + let mut loadedSize = (if (if (maxMem as i64) < fs.totalSizeToLoad { maxMem as i64 } else { fs.totalSizeToLoad - }) < (2 as core::ffi::c_uint).wrapping_mul((1 as core::ffi::c_uint) << 30) - as i64 + }) < (2 as core::ffi::c_uint) + .wrapping_mul((1 as core::ffi::c_uint) << 30) as i64 { if (maxMem as i64) < fs.totalSizeToLoad { maxMem as i64 @@ -455,8 +442,9 @@ pub unsafe fn DiB_trainFromFiles( memLimit as size_t }; } - srcBuffer = malloc(loadedSize.wrapping_add(NOISELENGTH as size_t)); - sampleSizes = malloc((fs.nbSamples as size_t).wrapping_mul(size_of::())) as *mut size_t; + let srcBuffer = malloc(loadedSize.wrapping_add(NOISELENGTH as size_t)); + let sampleSizes = + malloc((fs.nbSamples as size_t).wrapping_mul(size_of::())) as *mut size_t; if fs.nbSamples != 0 && sampleSizes.is_null() || srcBuffer.is_null() || dictBuffer.is_null() { fprintf( stderr, @@ -553,7 +541,7 @@ pub unsafe fn DiB_trainFromFiles( (loadedSize / ((1) << 20) as size_t) as core::ffi::c_uint, ); } - nbSamplesLoaded = DiB_loadFiles( + let nbSamplesLoaded = DiB_loadFiles( srcBuffer, &raw mut loadedSize, sampleSizes, diff --git a/programs/fileio.rs b/programs/fileio.rs index 98959182..cd1aef88 100644 --- a/programs/fileio.rs +++ b/programs/fileio.rs @@ -47,13 +47,12 @@ use crate::fileio_asyncio::{ }; use crate::timefn::{PTime, UTIL_clockSpanMicro, UTIL_clockSpanNano, UTIL_getTime, UTIL_time_t}; use crate::util::{ - stat, stat_t, FileNamesTable, UTIL_HumanReadableSize_t, UTIL_compareStr, - UTIL_createMirroredDestDirName, UTIL_getFileSize, UTIL_getFileSizeStat, UTIL_isBlockDevStat, - UTIL_isCompressedFile, UTIL_isConsole, UTIL_isDirectory, UTIL_isDirectoryStat, UTIL_isFIFOStat, - UTIL_isFdRegularFile, UTIL_isFileDescriptorPipe, UTIL_isRegularFile, UTIL_isRegularFileStat, - UTIL_isSameFile, UTIL_isSameFileStat, UTIL_makeHumanReadableSize, - UTIL_mirrorSourceFilesDirectories, UTIL_requireUserConfirmation, UTIL_setFDStat, UTIL_stat, - UTIL_utime, + stat, stat_t, FileNamesTable, UTIL_compareStr, UTIL_createMirroredDestDirName, + UTIL_getFileSize, UTIL_getFileSizeStat, UTIL_isBlockDevStat, UTIL_isCompressedFile, + UTIL_isConsole, UTIL_isDirectory, UTIL_isDirectoryStat, UTIL_isFIFOStat, UTIL_isFdRegularFile, + UTIL_isFileDescriptorPipe, UTIL_isRegularFile, UTIL_isRegularFileStat, UTIL_isSameFile, + UTIL_isSameFileStat, UTIL_makeHumanReadableSize, UTIL_mirrorSourceFilesDirectories, + UTIL_requireUserConfirmation, UTIL_setFDStat, UTIL_stat, UTIL_utime, }; enum lzma_internal_s {} @@ -921,14 +920,13 @@ unsafe fn FIO_openDstFile( } FIO_removeFile(dstFileName); } - let mut isDstRegFile: core::ffi::c_int = 0; let openflags = O_WRONLY | O_CREAT | O_TRUNC; let fd = open(dstFileName, openflags, mode as core::ffi::c_uint); let mut f = core::ptr::null_mut(); if fd != -(1) { f = fdopen(fd, b"wb\0" as *const u8 as *const core::ffi::c_char); } - isDstRegFile = UTIL_isFdRegularFile(fd); + let isDstRegFile = UTIL_isFdRegularFile(fd); if (*prefs).sparseFileSupport == 1 { (*prefs).sparseFileSupport = ZSTD_SPARSE_DEFAULT; if isDstRegFile == 0 { @@ -1040,8 +1038,6 @@ unsafe fn FIO_setDictBufferMalloc( prefs: *mut FIO_prefs_t, dictFileStat: *mut stat_t, ) -> size_t { - let mut fileHandle = core::ptr::null_mut::(); - let mut fileSize: size_t = 0; let bufferPtr: *mut *mut core::ffi::c_void = &raw mut (*dict).dictBuffer; assert!(!bufferPtr.is_null()); assert!(!dictFileStat.is_null()); @@ -1056,7 +1052,7 @@ unsafe fn FIO_setDictBufferMalloc( fileName, ); } - fileHandle = fopen(fileName, b"rb\0" as *const u8 as *const core::ffi::c_char); + let fileHandle = fopen(fileName, b"rb\0" as *const u8 as *const core::ffi::c_char); if fileHandle.is_null() { if g_display_prefs.displayLevel >= 1 { fprintf(stderr, b"zstd: \0" as *const u8 as *const core::ffi::c_char); @@ -1085,7 +1081,7 @@ unsafe fn FIO_setDictBufferMalloc( } exit(33); } - fileSize = UTIL_getFileSizeStat(dictFileStat) as size_t; + let fileSize = UTIL_getFileSizeStat(dictFileStat) as size_t; let dictSizeMax = (if (*prefs).patchFromMode != 0 { (*prefs).memLimit } else { @@ -1194,8 +1190,6 @@ unsafe fn FIO_setDictBufferMMap( prefs: *mut FIO_prefs_t, dictFileStat: *mut stat_t, ) -> size_t { - let mut fileHandle: core::ffi::c_int = 0; - let mut fileSize: u64 = 0; let bufferPtr: *mut *mut core::ffi::c_void = &raw mut (*dict).dictBuffer; assert!(!bufferPtr.is_null()); assert!(!dictFileStat.is_null()); @@ -1210,7 +1204,7 @@ unsafe fn FIO_setDictBufferMMap( fileName, ); } - fileHandle = open(fileName, O_RDONLY); + let fileHandle = open(fileName, O_RDONLY); if fileHandle == -(1) { if g_display_prefs.displayLevel >= 1 { fprintf(stderr, b"zstd: \0" as *const u8 as *const core::ffi::c_char); @@ -1239,7 +1233,7 @@ unsafe fn FIO_setDictBufferMMap( } exit(33); } - fileSize = UTIL_getFileSizeStat(dictFileStat); + let fileSize = UTIL_getFileSizeStat(dictFileStat); let dictSizeMax = (if (*prefs).patchFromMode != 0 { (*prefs).memLimit } else { @@ -1355,11 +1349,7 @@ pub unsafe fn FIO_checkFilenameCollisions( filenameTable: *mut *const core::ffi::c_char, nbFiles: core::ffi::c_uint, ) -> core::ffi::c_int { - let mut filenameTableSorted = core::ptr::null_mut::<*const core::ffi::c_char>(); - let mut prevElem = core::ptr::null::(); - let mut filename = core::ptr::null::(); - let mut u: core::ffi::c_uint = 0; - filenameTableSorted = + let filenameTableSorted = malloc(size_of::<*mut core::ffi::c_char>().wrapping_mul(nbFiles as size_t)) as *mut *const core::ffi::c_char; if filenameTableSorted.is_null() { @@ -1372,9 +1362,9 @@ pub unsafe fn FIO_checkFilenameCollisions( } return 1; } - u = 0; + let mut u: core::ffi::c_uint = 0; while u < nbFiles { - filename = strrchr(*filenameTable.offset(u as isize), PATH_SEP); + let filename = strrchr(*filenameTable.offset(u as isize), PATH_SEP); if filename.is_null() { let fresh0 = &mut (*filenameTableSorted.offset(u as isize)); *fresh0 = *filenameTable.offset(u as isize); @@ -1396,7 +1386,7 @@ pub unsafe fn FIO_checkFilenameCollisions( ) -> core::ffi::c_int, ), ); - prevElem = *filenameTableSorted.offset(0); + let mut prevElem = *filenameTableSorted.offset(0); u = 1; while u < nbFiles { if strcmp(prevElem, *filenameTableSorted.offset(u as isize)) == 0 @@ -1430,12 +1420,9 @@ unsafe fn FIO_createFilename_fromOutDir( outDirName: *const core::ffi::c_char, suffixLen: size_t, ) -> *mut core::ffi::c_char { - let mut filenameStart = core::ptr::null::(); - let mut separator: core::ffi::c_char = 0; - let mut result = core::ptr::null_mut::(); - separator = '/' as i32 as core::ffi::c_char; - filenameStart = extractFilename(path, separator); - result = calloc( + let separator = '/' as i32 as core::ffi::c_char; + let filenameStart = extractFilename(path, separator); + let result = calloc( 1, (strlen(outDirName)) .wrapping_add(1) @@ -1486,7 +1473,7 @@ unsafe fn FIO_createFilename_fromOutDir( } else { memcpy( result.add(strlen(outDirName)) as *mut core::ffi::c_void, - &raw mut separator as *const core::ffi::c_void, + &raw const separator as *const core::ffi::c_void, 1, ); memcpy( @@ -1885,7 +1872,6 @@ unsafe fn FIO_createCResources( let mut useMMap = ((*prefs).mmapDict == ZSTD_ParamSwitch_e::ZSTD_ps_enable) as core::ffi::c_int; let forceNoUseMMap = ((*prefs).mmapDict == ZSTD_ParamSwitch_e::ZSTD_ps_disable) as core::ffi::c_int; - let mut dictBufferType = FIO_mallocDict; let mut ress = cRess_t { dict: FIO_Dict_t { dictBuffer: core::ptr::null_mut::(), @@ -1974,7 +1960,7 @@ unsafe fn FIO_createCResources( cLevel, ); } - dictBufferType = (if useMMap != 0 && forceNoUseMMap == 0 { + let dictBufferType = (if useMMap != 0 && forceNoUseMMap == 0 { FIO_mmapDict as core::ffi::c_int } else { FIO_mallocDict as core::ffi::c_int @@ -2023,8 +2009,7 @@ unsafe fn FIO_createCResources( if (*prefs).adaptiveMode != 0 && (*prefs).ldmFlag == 0 && comprParams.windowLog == 0 { comprParams.windowLog = ADAPT_WINDOWLOG_DEFAULT as core::ffi::c_uint; } - let mut err: size_t = 0; - err = ZSTD_CCtx_setParameter( + let err = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_contentSizeFlag, (*prefs).contentSize, @@ -2068,8 +2053,7 @@ unsafe fn FIO_createCResources( } exit(11); } - let mut err_0: size_t = 0; - err_0 = ZSTD_CCtx_setParameter( + let err_0 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_dictIDFlag, (*prefs).dictIDFlag, @@ -2113,8 +2097,7 @@ unsafe fn FIO_createCResources( } exit(11); } - let mut err_1: size_t = 0; - err_1 = ZSTD_CCtx_setParameter( + let err_1 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_checksumFlag, (*prefs).checksumFlag, @@ -2158,8 +2141,7 @@ unsafe fn FIO_createCResources( } exit(11); } - let mut err_2: size_t = 0; - err_2 = ZSTD_CCtx_setParameter(ress.cctx, ZSTD_cParameter::ZSTD_c_compressionLevel, cLevel); + let err_2 = ZSTD_CCtx_setParameter(ress.cctx, ZSTD_cParameter::ZSTD_c_compressionLevel, cLevel); if ZSTD_isError(err_2) != 0 { if g_display_prefs.displayLevel >= 5 { fprintf( @@ -2199,8 +2181,7 @@ unsafe fn FIO_createCResources( } exit(11); } - let mut err_3: size_t = 0; - err_3 = ZSTD_CCtx_setParameter( + let err_3 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_targetCBlockSize, (*prefs).targetCBlockSize as core::ffi::c_int, @@ -2244,8 +2225,7 @@ unsafe fn FIO_createCResources( } exit(11); } - let mut err_4: size_t = 0; - err_4 = ZSTD_CCtx_setParameter( + let err_4 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_experimentalParam7, (*prefs).srcSizeHint, @@ -2289,8 +2269,7 @@ unsafe fn FIO_createCResources( } exit(11); } - let mut err_5: size_t = 0; - err_5 = ZSTD_CCtx_setParameter( + let err_5 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_enableLongDistanceMatching, (*prefs).ldmFlag, @@ -2334,8 +2313,7 @@ unsafe fn FIO_createCResources( } exit(11); } - let mut err_6: size_t = 0; - err_6 = ZSTD_CCtx_setParameter( + let err_6 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_ldmHashLog, (*prefs).ldmHashLog, @@ -2379,8 +2357,7 @@ unsafe fn FIO_createCResources( } exit(11); } - let mut err_7: size_t = 0; - err_7 = ZSTD_CCtx_setParameter( + let err_7 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_ldmMinMatch, (*prefs).ldmMinMatch, @@ -2425,8 +2402,7 @@ unsafe fn FIO_createCResources( exit(11); } if (*prefs).ldmBucketSizeLog != FIO_LDM_PARAM_NOTSET { - let mut err_8: size_t = 0; - err_8 = ZSTD_CCtx_setParameter( + let err_8 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_ldmBucketSizeLog, (*prefs).ldmBucketSizeLog, @@ -2472,8 +2448,7 @@ unsafe fn FIO_createCResources( } } if (*prefs).ldmHashRateLog != FIO_LDM_PARAM_NOTSET { - let mut err_9: size_t = 0; - err_9 = ZSTD_CCtx_setParameter( + let err_9 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_ldmHashRateLog, (*prefs).ldmHashRateLog, @@ -2518,8 +2493,7 @@ unsafe fn FIO_createCResources( exit(11); } } - let mut err_10: size_t = 0; - err_10 = ZSTD_CCtx_setParameter( + let err_10 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_experimentalParam14, (*prefs).useRowMatchFinder, @@ -2563,8 +2537,7 @@ unsafe fn FIO_createCResources( } exit(11); } - let mut err_11: size_t = 0; - err_11 = ZSTD_CCtx_setParameter( + let err_11 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_windowLog, comprParams.windowLog as core::ffi::c_int, @@ -2608,8 +2581,7 @@ unsafe fn FIO_createCResources( } exit(11); } - let mut err_12: size_t = 0; - err_12 = ZSTD_CCtx_setParameter( + let err_12 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_chainLog, comprParams.chainLog as core::ffi::c_int, @@ -2653,8 +2625,7 @@ unsafe fn FIO_createCResources( } exit(11); } - let mut err_13: size_t = 0; - err_13 = ZSTD_CCtx_setParameter( + let err_13 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_hashLog, comprParams.hashLog as core::ffi::c_int, @@ -2698,8 +2669,7 @@ unsafe fn FIO_createCResources( } exit(11); } - let mut err_14: size_t = 0; - err_14 = ZSTD_CCtx_setParameter( + let err_14 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_searchLog, comprParams.searchLog as core::ffi::c_int, @@ -2743,8 +2713,7 @@ unsafe fn FIO_createCResources( } exit(11); } - let mut err_15: size_t = 0; - err_15 = ZSTD_CCtx_setParameter( + let err_15 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_minMatch, comprParams.minMatch as core::ffi::c_int, @@ -2788,8 +2757,7 @@ unsafe fn FIO_createCResources( } exit(11); } - let mut err_16: size_t = 0; - err_16 = ZSTD_CCtx_setParameter( + let err_16 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_targetLength, comprParams.targetLength as core::ffi::c_int, @@ -2833,8 +2801,7 @@ unsafe fn FIO_createCResources( } exit(11); } - let mut err_17: size_t = 0; - err_17 = ZSTD_CCtx_setParameter( + let err_17 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_strategy, comprParams.strategy as core::ffi::c_int, @@ -2878,8 +2845,7 @@ unsafe fn FIO_createCResources( } exit(11); } - let mut err_18: size_t = 0; - err_18 = ZSTD_CCtx_setParameter( + let err_18 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_experimentalParam5, (*prefs).literalCompressionMode.to_i32(), @@ -2923,8 +2889,7 @@ unsafe fn FIO_createCResources( } exit(11); } - let mut err_19: size_t = 0; - err_19 = ZSTD_CCtx_setParameter(ress.cctx, ZSTD_cParameter::ZSTD_c_experimentalParam8, 1); + let err_19 = ZSTD_CCtx_setParameter(ress.cctx, ZSTD_cParameter::ZSTD_c_experimentalParam8, 1); if ZSTD_isError(err_19) != 0 { if g_display_prefs.displayLevel >= 5 { fprintf( @@ -2971,8 +2936,7 @@ unsafe fn FIO_createCResources( (*prefs).nbWorkers, ); } - let mut err_20: size_t = 0; - err_20 = ZSTD_CCtx_setParameter( + let err_20 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_nbWorkers, (*prefs).nbWorkers, @@ -3016,8 +2980,8 @@ unsafe fn FIO_createCResources( } exit(11); } - let mut err_21: size_t = 0; - err_21 = ZSTD_CCtx_setParameter(ress.cctx, ZSTD_cParameter::ZSTD_c_jobSize, (*prefs).jobSize); + let err_21 = + ZSTD_CCtx_setParameter(ress.cctx, ZSTD_cParameter::ZSTD_c_jobSize, (*prefs).jobSize); if ZSTD_isError(err_21) != 0 { if g_display_prefs.displayLevel >= 5 { fprintf( @@ -3065,8 +3029,7 @@ unsafe fn FIO_createCResources( (*prefs).overlapLog, ); } - let mut err_22: size_t = 0; - err_22 = ZSTD_CCtx_setParameter( + let err_22 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_overlapLog, (*prefs).overlapLog, @@ -3111,8 +3074,7 @@ unsafe fn FIO_createCResources( exit(11); } } - let mut err_23: size_t = 0; - err_23 = ZSTD_CCtx_setParameter( + let err_23 = ZSTD_CCtx_setParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_experimentalParam1, (*prefs).rsyncable, @@ -3157,8 +3119,7 @@ unsafe fn FIO_createCResources( exit(11); } if (*prefs).patchFromMode != 0 { - let mut err_24: size_t = 0; - err_24 = ZSTD_CCtx_refPrefix(ress.cctx, ress.dict.dictBuffer, ress.dict.dictBufferSize); + let err_24 = ZSTD_CCtx_refPrefix(ress.cctx, ress.dict.dictBuffer, ress.dict.dictBufferSize); if ZSTD_isError(err_24) != 0 { if g_display_prefs.displayLevel >= 5 { fprintf( @@ -3199,8 +3160,7 @@ unsafe fn FIO_createCResources( exit(11); } } else { - let mut err_25: size_t = 0; - err_25 = ZSTD_CCtx_loadDictionary_byReference( + let err_25 = ZSTD_CCtx_loadDictionary_byReference( ress.cctx, ress.dict.dictBuffer, ress.dict.dictBufferSize, @@ -3278,7 +3238,6 @@ unsafe fn FIO_compressGzFrame( adler: 0, reserved: 0, }; - let mut writeJob = core::ptr::null_mut(); if compressionLevel > Z_BEST_COMPRESSION { compressionLevel = Z_BEST_COMPRESSION; } @@ -3327,13 +3286,12 @@ unsafe fn FIO_compressGzFrame( } exit(71); } - writeJob = AIO_WritePool_acquireJob((*ress).writeCtx); + let mut writeJob = AIO_WritePool_acquireJob((*ress).writeCtx); strm.next_in = core::ptr::null_mut::(); strm.avail_in = 0; strm.next_out = (*writeJob).buffer as *mut Bytef; strm.avail_out = (*writeJob).bufferSize as uInt; loop { - let mut ret_0: core::ffi::c_int = 0; if strm.avail_in == 0 { AIO_ReadPool_fillBuffer((*ress).readCtx, ZSTD_CStreamInSize()); if (*(*ress).readCtx).srcBufferLoaded == 0 { @@ -3345,7 +3303,7 @@ unsafe fn FIO_compressGzFrame( strm.avail_in = (*(*ress).readCtx).srcBufferLoaded as uInt; } let availBefore = strm.avail_in as size_t; - ret_0 = deflate(&raw mut strm, Z_NO_FLUSH); + let ret_0 = deflate(&raw mut strm, Z_NO_FLUSH); AIO_ReadPool_consumeBytes( (*ress).readCtx, availBefore.wrapping_sub(strm.avail_in as size_t), @@ -3554,8 +3512,7 @@ unsafe fn FIO_compressLzmaFrame( } }; let mut action = LZMA_RUN; - let mut ret = LZMA_OK; - let mut writeJob = core::ptr::null_mut(); + let mut ret; compressionLevel = compressionLevel.clamp(0, 9); if plain_lzma != 0 { let mut opt_lzma = lzma_options_lzma { @@ -3685,7 +3642,7 @@ unsafe fn FIO_compressLzmaFrame( exit(83); } } - writeJob = AIO_WritePool_acquireJob((*ress).writeCtx); + let mut writeJob = AIO_WritePool_acquireJob((*ress).writeCtx); strm.next_out = (*writeJob).buffer as *mut u8; strm.avail_out = (*writeJob).bufferSize; strm.next_in = core::ptr::null::(); @@ -3852,8 +3809,7 @@ unsafe fn FIO_compressZstdFrame( } if fileSize != UTIL_FILESIZE_UNKNOWN as u64 { pledgedSrcSize = fileSize; - let mut err: size_t = 0; - err = ZSTD_CCtx_setPledgedSrcSize(ress.cctx, fileSize as core::ffi::c_ulonglong); + let err = ZSTD_CCtx_setPledgedSrcSize(ress.cctx, fileSize as core::ffi::c_ulonglong); if ZSTD_isError(err) != 0 { if g_display_prefs.displayLevel >= 5 { fprintf( @@ -3895,8 +3851,7 @@ unsafe fn FIO_compressZstdFrame( } } else if (*prefs).streamSrcSize > 0 { pledgedSrcSize = (*prefs).streamSrcSize as u64; - let mut err_0: size_t = 0; - err_0 = ZSTD_CCtx_setPledgedSrcSize( + let err_0 = ZSTD_CCtx_setPledgedSrcSize( ress.cctx, (*prefs).streamSrcSize as core::ffi::c_ulonglong, ); @@ -3941,13 +3896,7 @@ unsafe fn FIO_compressZstdFrame( } } let mut windowLog: core::ffi::c_int = 0; - let mut windowSize = UTIL_HumanReadableSize_t { - value: 0., - precision: 0, - suffix: core::ptr::null::(), - }; - let mut err_1: size_t = 0; - err_1 = ZSTD_CCtx_getParameter( + let err_1 = ZSTD_CCtx_getParameter( ress.cctx, ZSTD_cParameter::ZSTD_c_windowLog, &raw mut windowLog, @@ -3999,7 +3948,7 @@ unsafe fn FIO_compressZstdFrame( windowLog = cParams.windowLog as core::ffi::c_int; } } - windowSize = UTIL_makeHumanReadableSize( + let windowSize = UTIL_makeHumanReadableSize( (if 1 > (if (1) << windowLog < pledgedSrcSize as core::ffi::c_ulonglong { (1) << windowLog @@ -4025,7 +3974,6 @@ unsafe fn FIO_compressZstdFrame( ); } loop { - let mut stillToFlush: size_t = 0; let inSize = AIO_ReadPool_fillBuffer(ress.readCtx, ZSTD_CStreamInSize()); let mut inBuff = setInBuffer( (*ress.readCtx).srcBuffer as *const core::ffi::c_void, @@ -4043,7 +3991,7 @@ unsafe fn FIO_compressZstdFrame( if (*ress.readCtx).srcBufferLoaded == 0 || *readsize == fileSize { directive = ZSTD_e_end; } - stillToFlush = 1; + let mut stillToFlush = 1; while inBuff.pos != inBuff.size || directive as core::ffi::c_uint == ZSTD_e_end as core::ffi::c_int as core::ffi::c_uint && stillToFlush != 0 @@ -4469,7 +4417,6 @@ unsafe fn FIO_compressFilename_internal( let timeStart = UTIL_getTime(); let cpuStart = Instant::now(); let mut readsize = 0; - let mut compressedfilesize = 0; let fileSize = UTIL_getFileSize(srcFileName); if g_display_prefs.displayLevel >= 5 { fprintf( @@ -4479,28 +4426,24 @@ unsafe fn FIO_compressFilename_internal( fileSize as core::ffi::c_ulonglong, ); } - match (*prefs).compressionType as core::ffi::c_uint { - 1 => { - compressedfilesize = FIO_compressGzFrame( - &raw const ress, - srcFileName, - fileSize, - compressionLevel, - &raw mut readsize, - ) as u64; - } - 2 | 3 => { - compressedfilesize = FIO_compressLzmaFrame( - &raw mut ress, - srcFileName, - fileSize, - compressionLevel, - &raw mut readsize, - ((*prefs).compressionType as core::ffi::c_uint - == FIO_lzmaCompression as core::ffi::c_int as core::ffi::c_uint) - as core::ffi::c_int, - ) as u64; - } + let compressedfilesize = match (*prefs).compressionType as core::ffi::c_uint { + 1 => FIO_compressGzFrame( + &raw const ress, + srcFileName, + fileSize, + compressionLevel, + &raw mut readsize, + ) as u64, + 2 | 3 => FIO_compressLzmaFrame( + &raw mut ress, + srcFileName, + fileSize, + compressionLevel, + &raw mut readsize, + ((*prefs).compressionType as core::ffi::c_uint + == FIO_lzmaCompression as core::ffi::c_int as core::ffi::c_uint) + as core::ffi::c_int, + ) as u64, 4 => { if g_display_prefs.displayLevel >= 1 { fprintf(stderr, b"zstd: \0" as *const u8 as *const core::ffi::c_char); @@ -4533,18 +4476,16 @@ unsafe fn FIO_compressFilename_internal( } exit(20); } - _ => { - compressedfilesize = FIO_compressZstdFrame( - fCtx, - prefs, - &raw const ress, - srcFileName, - fileSize, - compressionLevel, - &raw mut readsize, - ) as u64; - } - } + _ => FIO_compressZstdFrame( + fCtx, + prefs, + &raw const ress, + srcFileName, + fileSize, + compressionLevel, + &raw mut readsize, + ) as u64, + }; (*fCtx).totalBytesInput = ((*fCtx).totalBytesInput).wrapping_add(readsize as size_t); (*fCtx).totalBytesOutput = ((*fCtx).totalBytesOutput).wrapping_add(compressedfilesize as size_t); @@ -4631,7 +4572,6 @@ unsafe fn FIO_compressFilename_dstFile( compressionLevel: core::ffi::c_int, ) -> core::ffi::c_int { let mut closeDstFile = 0; - let mut result: core::ffi::c_int = 0; let mut transferStat = 0; let mut dstFd = -(1); assert!(!(AIO_ReadPool_getFile(ress.readCtx)).is_null()); @@ -4667,7 +4607,7 @@ unsafe fn FIO_compressFilename_dstFile( AIO_WritePool_setFile(ress.writeCtx, dstFile); addHandler(dstFileName); } - result = FIO_compressFilename_internal( + let mut result = FIO_compressFilename_internal( fCtx, prefs, ress, @@ -4830,8 +4770,6 @@ unsafe fn FIO_compressFilename_srcFile( srcFileName: *const core::ffi::c_char, compressionLevel: core::ffi::c_int, ) -> core::ffi::c_int { - let mut result: core::ffi::c_int = 0; - let mut srcFile = core::ptr::null_mut::(); let mut srcFileStat = stat { st_dev: 0, st_ino: 0, @@ -4911,7 +4849,7 @@ unsafe fn FIO_compressFilename_srcFile( } return 0; } - srcFile = FIO_openSrcFile(prefs, srcFileName, &raw mut srcFileStat); + let srcFile = FIO_openSrcFile(prefs, srcFileName, &raw mut srcFileStat); if srcFile.is_null() { return 1; } @@ -4926,7 +4864,7 @@ unsafe fn FIO_compressFilename_srcFile( AIO_WritePool_setAsync(ress.writeCtx, 1); } AIO_ReadPool_setFile(ress.readCtx, srcFile); - result = FIO_compressFilename_dstFile( + let result = FIO_compressFilename_dstFile( fCtx, prefs, ress, @@ -5195,12 +5133,10 @@ unsafe fn FIO_getLargestFileSize( inFileNames: *mut *const core::ffi::c_char, nbFiles: core::ffi::c_uint, ) -> core::ffi::c_ulonglong { - let mut i: size_t = 0; - let mut fileSize: core::ffi::c_ulonglong = 0; let mut maxFileSize = 0; - i = 0; + let mut i: size_t = 0; while i < nbFiles as size_t { - fileSize = UTIL_getFileSize(*inFileNames.add(i)) as core::ffi::c_ulonglong; + let fileSize = UTIL_getFileSize(*inFileNames.add(i)) as core::ffi::c_ulonglong; maxFileSize = if fileSize > maxFileSize { fileSize } else { @@ -5228,7 +5164,7 @@ pub unsafe fn FIO_compressMultipleFilenames( compressionLevel: core::ffi::c_int, comprParams: ZSTD_compressionParameters, ) -> core::ffi::c_int { - let mut status: core::ffi::c_int = 0; + let mut status: core::ffi::c_int; let mut error = 0; let mut ress = FIO_createCResources( prefs, @@ -5242,12 +5178,11 @@ pub unsafe fn FIO_compressMultipleFilenames( assert!(!outFileName.is_null() || !suffix.is_null()); if !outFileName.is_null() { // output into a single destination (stdout typically) - let mut dstFile = core::ptr::null_mut::(); if FIO_multiFilesConcatWarning(fCtx, prefs, outFileName, 1) != 0 { FIO_freeCResources(&raw mut ress); return 1; } - dstFile = FIO_openDstFile( + let dstFile = FIO_openDstFile( fCtx, prefs, core::ptr::null(), @@ -5305,14 +5240,14 @@ pub unsafe fn FIO_compressMultipleFilenames( while (*fCtx).currFileIdx < (*fCtx).nbFilesTotal { let srcFileName = *inFileNamesTable.offset((*fCtx).currFileIdx as isize); - let mut dstFileName = core::ptr::null::(); - if !outMirroredRootDirName.is_null() { + let dstFileName = if !outMirroredRootDirName.is_null() { let validMirroredDirName = UTIL_createMirroredDestDirName(srcFileName, outMirroredRootDirName); if !validMirroredDirName.is_null() { - dstFileName = + let dstFileName = FIO_determineCompressedName(srcFileName, validMirroredDirName, suffix); free(validMirroredDirName as *mut core::ffi::c_void); + dstFileName } else { if g_display_prefs.displayLevel >= 2 { eprintln!( @@ -5326,8 +5261,8 @@ pub unsafe fn FIO_compressMultipleFilenames( continue; } } else { - dstFileName = FIO_determineCompressedName(srcFileName, outDirName, suffix); - } + FIO_determineCompressedName(srcFileName, outDirName, suffix) + }; status = FIO_compressFilename_srcFile( fCtx, prefs, @@ -5484,8 +5419,7 @@ unsafe fn FIO_createDResources( } exit(60); } - let mut err: size_t = 0; - err = ZSTD_DCtx_setMaxWindowSize(ress.dctx, (*prefs).memLimit as size_t); + let err = ZSTD_DCtx_setMaxWindowSize(ress.dctx, (*prefs).memLimit as size_t); if ZSTD_isError(err) != 0 { if g_display_prefs.displayLevel >= 5 { fprintf( @@ -5525,8 +5459,7 @@ unsafe fn FIO_createDResources( } exit(11); } - let mut err_0: size_t = 0; - err_0 = ZSTD_DCtx_setParameter( + let err_0 = ZSTD_DCtx_setParameter( ress.dctx, ZSTD_dParameter::ZSTD_d_experimentalParam3, ((*prefs).checksumFlag == 0) as core::ffi::c_int, @@ -5582,8 +5515,7 @@ unsafe fn FIO_createDResources( &raw mut statbuf, dictBufferType, ); - let mut err_1: size_t = 0; - err_1 = ZSTD_DCtx_reset(ress.dctx, ZSTD_ResetDirective::ZSTD_reset_session_only); + let err_1 = ZSTD_DCtx_reset(ress.dctx, ZSTD_ResetDirective::ZSTD_reset_session_only); if ZSTD_isError(err_1) != 0 { if g_display_prefs.displayLevel >= 5 { fprintf( @@ -5624,8 +5556,7 @@ unsafe fn FIO_createDResources( exit(11); } if (*prefs).patchFromMode != 0 { - let mut err_2: size_t = 0; - err_2 = ZSTD_DCtx_refPrefix(ress.dctx, ress.dict.dictBuffer, ress.dict.dictBufferSize); + let err_2 = ZSTD_DCtx_refPrefix(ress.dctx, ress.dict.dictBuffer, ress.dict.dictBufferSize); if ZSTD_isError(err_2) != 0 { if g_display_prefs.displayLevel >= 5 { fprintf( @@ -5666,8 +5597,7 @@ unsafe fn FIO_createDResources( exit(11); } } else { - let mut err_3: size_t = 0; - err_3 = ZSTD_DCtx_loadDictionary_byReference( + let err_3 = ZSTD_DCtx_loadDictionary_byReference( ress.dctx, ress.dict.dictBuffer, ress.dict.dictBufferSize, @@ -5718,8 +5648,7 @@ unsafe fn FIO_createDResources( } unsafe fn FIO_freeDResources(mut ress: dRess_t) { FIO_freeDict(&raw mut ress.dict); - let mut err: size_t = 0; - err = ZSTD_freeDStream(ress.dctx); + let err = ZSTD_freeDStream(ress.dctx); if ZSTD_isError(err) != 0 { if g_display_prefs.displayLevel >= 5 { fprintf( @@ -5780,8 +5709,7 @@ unsafe fn FIO_passThrough(ress: *mut dRess_t) -> core::ffi::c_int { AIO_ReadPool_fillBuffer((*ress).readCtx, blockSize); #[expect(clippy::while_immutable_condition)] while (*(*ress).readCtx).srcBufferLoaded != 0 { - let mut writeSize: size_t = 0; - writeSize = if blockSize < (*(*ress).readCtx).srcBufferLoaded { + let writeSize = if blockSize < (*(*ress).readCtx).srcBufferLoaded { blockSize } else { (*(*ress).readCtx).srcBufferLoaded @@ -6027,7 +5955,6 @@ unsafe fn FIO_decompressGzFrame( }; let mut flush = Z_NO_FLUSH; let mut decodingError = 0; - let mut writeJob = core::ptr::null_mut(); strm.zalloc = None; strm.zfree = None; strm.opaque = core::ptr::null_mut(); @@ -6042,13 +5969,12 @@ unsafe fn FIO_decompressGzFrame( { return FIO_ERROR_FRAME_DECODING as core::ffi::c_ulonglong; } - writeJob = AIO_WritePool_acquireJob((*ress).writeCtx); + let mut writeJob = AIO_WritePool_acquireJob((*ress).writeCtx); strm.next_out = (*writeJob).buffer as *mut Bytef; strm.avail_out = (*writeJob).bufferSize as uInt; strm.avail_in = (*(*ress).readCtx).srcBufferLoaded as uInt; strm.next_in = (*(*ress).readCtx).srcBuffer as *mut core::ffi::c_uchar; loop { - let mut ret: core::ffi::c_int = 0; if strm.avail_in == 0 { AIO_ReadPool_consumeAndRefill((*ress).readCtx); if (*(*ress).readCtx).srcBufferLoaded == 0 { @@ -6057,7 +5983,7 @@ unsafe fn FIO_decompressGzFrame( strm.next_in = (*(*ress).readCtx).srcBuffer as *mut core::ffi::c_uchar; strm.avail_in = (*(*ress).readCtx).srcBufferLoaded as uInt; } - ret = inflate(&raw mut strm, flush); + let ret = inflate(&raw mut strm, flush); if ret == Z_BUF_ERROR { if g_display_prefs.displayLevel >= 1 { fprintf( @@ -6144,16 +6070,14 @@ unsafe fn FIO_decompressLzmaFrame( } }; let mut action = LZMA_RUN; - let mut initRet = LZMA_OK; let mut decodingError = 0; - let mut writeJob = core::ptr::null_mut(); strm.next_in = core::ptr::null::(); strm.avail_in = 0; - if plain_lzma != 0 { - initRet = lzma_alone_decoder(&raw mut strm, UINT64_MAX); + let initRet = if plain_lzma != 0 { + lzma_alone_decoder(&raw mut strm, UINT64_MAX) } else { - initRet = lzma_stream_decoder(&raw mut strm, UINT64_MAX, 0); - } + lzma_stream_decoder(&raw mut strm, UINT64_MAX, 0) + }; if initRet as core::ffi::c_uint != LZMA_OK as core::ffi::c_int as core::ffi::c_uint { if g_display_prefs.displayLevel >= 1 { fprintf( @@ -6170,13 +6094,12 @@ unsafe fn FIO_decompressLzmaFrame( } return FIO_ERROR_FRAME_DECODING as core::ffi::c_ulonglong; } - writeJob = AIO_WritePool_acquireJob((*ress).writeCtx); + let mut writeJob = AIO_WritePool_acquireJob((*ress).writeCtx); strm.next_out = (*writeJob).buffer as *mut u8; strm.avail_out = (*writeJob).bufferSize; strm.next_in = (*(*ress).readCtx).srcBuffer as *const u8; strm.avail_in = (*(*ress).readCtx).srcBufferLoaded; loop { - let mut ret = LZMA_OK; if strm.avail_in == 0 { AIO_ReadPool_consumeAndRefill((*ress).readCtx); if (*(*ress).readCtx).srcBufferLoaded == 0 { @@ -6185,7 +6108,7 @@ unsafe fn FIO_decompressLzmaFrame( strm.next_in = (*(*ress).readCtx).srcBuffer as *const u8; strm.avail_in = (*(*ress).readCtx).srcBufferLoaded; } - ret = lzma_code(&raw mut strm, action); + let ret = lzma_code(&raw mut strm, action); if ret as core::ffi::c_uint == LZMA_BUF_ERROR as core::ffi::c_int as core::ffi::c_uint { if g_display_prefs.displayLevel >= 1 { fprintf( @@ -6255,9 +6178,8 @@ unsafe fn FIO_decompressFrames( assert!(passThrough == 0 || passThrough == 1); loop { let toRead = 4; - let mut buf = core::ptr::null::(); AIO_ReadPool_fillBuffer(ress.readCtx, toRead); - buf = (*ress.readCtx).srcBuffer as *const u8; + let buf = (*ress.readCtx).srcBuffer as *const u8; if (*ress.readCtx).srcBufferLoaded == 0 { if readSomething == 0 { if g_display_prefs.displayLevel >= 1 { @@ -6387,12 +6309,10 @@ unsafe fn FIO_decompressDstFile( srcFileName: *const core::ffi::c_char, srcFileStat: *const stat_t, ) -> core::ffi::c_int { - let mut result: core::ffi::c_int = 0; let mut releaseDstFile = 0; let mut transferStat = 0; let mut dstFd = 0; if (AIO_WritePool_getFile(ress.writeCtx)).is_null() && (*prefs).testMode == 0 { - let mut dstFile = core::ptr::null_mut::(); let mut dstFilePermissions = DEFAULT_FILE_PERMISSIONS; if strcmp(srcFileName, stdinmark.as_ptr()) != 0 && strcmp(dstFileName, stdoutmark.as_ptr()) != 0 @@ -6402,7 +6322,7 @@ unsafe fn FIO_decompressDstFile( dstFilePermissions = TEMPORARY_FILE_PERMISSIONS; } releaseDstFile = 1; - dstFile = FIO_openDstFile(fCtx, prefs, srcFileName, dstFileName, dstFilePermissions); + let dstFile = FIO_openDstFile(fCtx, prefs, srcFileName, dstFileName, dstFilePermissions); if dstFile.is_null() { return 1; } @@ -6410,7 +6330,7 @@ unsafe fn FIO_decompressDstFile( AIO_WritePool_setFile(ress.writeCtx, dstFile); addHandler(dstFileName); } - result = FIO_decompressFrames(fCtx, ress, prefs, dstFileName, srcFileName); + let mut result = FIO_decompressFrames(fCtx, ress, prefs, dstFileName, srcFileName); if releaseDstFile != 0 { clearHandler(); if transferStat != 0 { @@ -6442,7 +6362,6 @@ unsafe fn FIO_decompressSrcFile( dstFileName: *const core::ffi::c_char, srcFileName: *const core::ffi::c_char, ) -> core::ffi::c_int { - let mut srcFile = core::ptr::null_mut::(); let mut srcFileStat = stat { st_dev: 0, st_ino: 0, @@ -6469,7 +6388,6 @@ unsafe fn FIO_decompressSrcFile( }, __glibc_reserved: [0; 3], }; - let mut result: core::ffi::c_int = 0; let mut fileSize = UTIL_FILESIZE_UNKNOWN as u64; if UTIL_isDirectory(srcFileName) != 0 { if g_display_prefs.displayLevel >= 1 { @@ -6481,7 +6399,7 @@ unsafe fn FIO_decompressSrcFile( } return 1; } - srcFile = FIO_openSrcFile(prefs, srcFileName, &raw mut srcFileStat); + let srcFile = FIO_openSrcFile(prefs, srcFileName, &raw mut srcFileStat); if srcFile.is_null() { return 1; } @@ -6496,7 +6414,7 @@ unsafe fn FIO_decompressSrcFile( AIO_WritePool_setAsync(ress.writeCtx, 1); } AIO_ReadPool_setFile(ress.readCtx, srcFile); - result = FIO_decompressDstFile( + let result = FIO_decompressDstFile( fCtx, prefs, ress, @@ -6559,12 +6477,10 @@ unsafe fn FIO_determineDstName( ) -> *const core::ffi::c_char { static mut dfnbCapacity: size_t = 0; static mut dstFileNameBuffer: *mut core::ffi::c_char = core::ptr::null_mut(); - let mut dstFileNameEndPos: size_t = 0; let mut outDirFilename = core::ptr::null_mut(); let mut dstSuffix = b"\0" as *const u8 as *const core::ffi::c_char; let mut dstSuffixLen = 0; let mut sfnSize = strlen(srcFileName); - let mut srcSuffixLen: size_t = 0; let srcSuffix: *const core::ffi::c_char = strrchr(srcFileName, '.' as i32); if strcmp(srcFileName, stdinmark.as_ptr()) == 0 { return stdoutmark.as_ptr(); @@ -6581,7 +6497,7 @@ unsafe fn FIO_determineDstName( } return core::ptr::null(); } - srcSuffixLen = strlen(srcSuffix); + let srcSuffixLen = strlen(srcSuffix); let matchedSuffix = suffixList .iter() .find(|suffix| strcmp(suffix.as_ptr(), srcSuffix) == 0); @@ -6640,7 +6556,7 @@ unsafe fn FIO_determineDstName( } } assert!(!dstFileNameBuffer.is_null()); - dstFileNameEndPos = sfnSize.wrapping_sub(srcSuffixLen); + let dstFileNameEndPos = sfnSize.wrapping_sub(srcSuffixLen); if !outDirFilename.is_null() { memcpy( dstFileNameBuffer as *mut core::ffi::c_void, @@ -6667,7 +6583,6 @@ pub unsafe fn FIO_decompressMultipleFilenames( outFileName: *const core::ffi::c_char, dictFileName: *const core::ffi::c_char, ) -> core::ffi::c_int { - let mut status: core::ffi::c_int = 0; let mut error = 0; let ress = FIO_createDResources(prefs, dictFileName); if !outFileName.is_null() { @@ -6718,7 +6633,7 @@ pub unsafe fn FIO_decompressMultipleFilenames( AIO_WritePool_setFile(ress.writeCtx, dstFile); } while (*fCtx).currFileIdx < (*fCtx).nbFilesTotal { - status = FIO_decompressSrcFile( + let status = FIO_decompressSrcFile( fCtx, prefs, ress, @@ -6790,7 +6705,7 @@ pub unsafe fn FIO_decompressMultipleFilenames( if dstFileName.is_null() { error = 1; } else { - status = FIO_decompressSrcFile(fCtx, prefs, ress, dstFileName, srcFileName); + let status = FIO_decompressSrcFile(fCtx, prefs, ress, dstFileName, srcFileName); if status == 0 { (*fCtx).nbFilesProcessed += 1; } @@ -6983,7 +6898,6 @@ unsafe fn FIO_analyzeFrames(info: *mut fileInfo_t, srcFile: *mut FILE) -> InfoEr } return info_frame_error; } - let mut lastBlock = 0; loop { let mut blockHeaderBuffer: [u8; 3] = [0; 3]; if fread( @@ -7028,7 +6942,7 @@ unsafe fn FIO_analyzeFrames(info: *mut fileInfo_t, srcFile: *mut FILE) -> InfoEr } return info_frame_error; } - lastBlock = (blockHeader & 1) as core::ffi::c_int; + let lastBlock = (blockHeader & 1) as core::ffi::c_int; if fseek(srcFile, blockSize, 1) != 0 { if g_display_prefs.displayLevel >= 1 { fprintf( @@ -7102,7 +7016,6 @@ unsafe fn getFileInfo_fileConfirmed( info: *mut fileInfo_t, inFileName: *const core::ffi::c_char, ) -> InfoError { - let mut status = info_success; let mut srcFileStat = stat { st_dev: 0, st_ino: 0, @@ -7144,7 +7057,7 @@ unsafe fn getFileInfo_fileConfirmed( return info_file_error; } (*info).compressedSize = UTIL_getFileSizeStat(&raw const srcFileStat); - status = FIO_analyzeFrames(info, srcFile); + let status = FIO_analyzeFrames(info, srcFile); fclose(srcFile); (*info).nbFiles = 1; status @@ -7387,7 +7300,6 @@ pub unsafe fn FIO_listMultipleFiles( displayLevel: core::ffi::c_int, ) -> core::ffi::c_int { let mut u: core::ffi::c_uint = 0; - u = 0; while u < numFiles { if strcmp( *filenameTable.offset(u as isize), @@ -7447,7 +7359,6 @@ pub unsafe fn FIO_listMultipleFiles( ptr::write_bytes(&raw mut total as *mut u8, 0, size_of::()); total.usesCheck = 1; let mut u_0: core::ffi::c_uint = 0; - u_0 = 0; while u_0 < numFiles { error |= FIO_listFile( &raw mut total, diff --git a/programs/fileio_asyncio.rs b/programs/fileio_asyncio.rs index f755352e..120fbdd9 100644 --- a/programs/fileio_asyncio.rs +++ b/programs/fileio_asyncio.rs @@ -206,13 +206,12 @@ unsafe fn AIO_fwriteSparse( .wrapping_sub((1 as core::ffi::c_uint).wrapping_mul((1 as core::ffi::c_uint) << 30)); } while ptrT < bufferTEnd { - let mut nb0T: size_t = 0; let mut seg0SizeT = segmentSizeT; if seg0SizeT > bufferSizeT { seg0SizeT = bufferSizeT; } bufferSizeT = bufferSizeT.wrapping_sub(seg0SizeT); - nb0T = 0; + let mut nb0T: size_t = 0; while nb0T < seg0SizeT && *ptrT.add(nb0T) == 0 { nb0T = nb0T.wrapping_add(1); } @@ -572,7 +571,6 @@ unsafe fn AIO_IOPool_init( poolFunction: POOL_function, bufferSize: size_t, ) { - let mut i: core::ffi::c_int = 0; AIO_IOPool_createThreadPool(ctx, prefs); (*ctx).prefs = prefs; (*ctx).poolFunction = poolFunction; @@ -582,7 +580,7 @@ unsafe fn AIO_IOPool_init( 2 }; (*ctx).availableJobsCount = (*ctx).totalIoJobs; - i = 0; + let mut i: core::ffi::c_int = 0; while i < (*ctx).availableJobsCount { let fresh0 = &mut (*((*ctx).availableJobs).as_mut_ptr().offset(i as isize)); *fresh0 = AIO_IOPool_createIoJob(ctx, bufferSize) as *mut core::ffi::c_void; @@ -628,7 +626,6 @@ unsafe fn AIO_IOPool_setThreaded(ctx: *mut IOPoolCtx_t, threaded: core::ffi::c_i } } unsafe fn AIO_IOPool_destroy(ctx: *mut IOPoolCtx_t) { - let mut i: core::ffi::c_int = 0; if !((*ctx).threadPool).is_null() { AIO_IOPool_join(ctx); assert!((*ctx).availableJobsCount == (*ctx).totalIoJobs); @@ -636,7 +633,7 @@ unsafe fn AIO_IOPool_destroy(ctx: *mut IOPoolCtx_t) { pthread_mutex_destroy(&raw mut (*ctx).ioJobsMutex); } assert!(((*ctx).file).is_null()); - i = 0; + let mut i: core::ffi::c_int = 0; while i < (*ctx).availableJobsCount { let job = *((*ctx).availableJobs).as_mut_ptr().offset(i as isize) as *mut IOJob_t; free((*job).buffer); @@ -645,12 +642,11 @@ unsafe fn AIO_IOPool_destroy(ctx: *mut IOPoolCtx_t) { } } unsafe fn AIO_IOPool_acquireJob(ctx: *mut IOPoolCtx_t) -> *mut IOJob_t { - let mut job = core::ptr::null_mut::(); assert!(!((*ctx).file).is_null() || (*(*ctx).prefs).testMode != 0); AIO_IOPool_lockJobsMutex(ctx); assert!((*ctx).availableJobsCount > 0); (*ctx).availableJobsCount -= 1; - job = *((*ctx).availableJobs) + let job = *((*ctx).availableJobs) .as_mut_ptr() .offset((*ctx).availableJobsCount as isize) as *mut IOJob_t; AIO_IOPool_unlockJobsMutex(ctx); @@ -779,7 +775,6 @@ pub unsafe fn AIO_WritePool_setAsync(ctx: *mut WritePoolCtx_t, async_0: core::ff } unsafe fn AIO_ReadPool_releaseAllCompletedJobs(ctx: *mut ReadPoolCtx_t) { let mut i: core::ffi::c_int = 0; - i = 0; while i < (*ctx).completedJobsCount { let job = *((*ctx).completedJobs).as_mut_ptr().offset(i as isize) as *mut IOJob_t; AIO_IOPool_releaseIoJob(job); @@ -803,11 +798,9 @@ unsafe fn AIO_ReadPool_addJobToCompleted(job: *mut IOJob_t) { unsafe fn AIO_ReadPool_findNextWaitingOffsetCompletedJob_locked( ctx: *mut ReadPoolCtx_t, ) -> *mut IOJob_t { - let mut job = core::ptr::null_mut(); let mut i: core::ffi::c_int = 0; - i = 0; while i < (*ctx).completedJobsCount { - job = *((*ctx).completedJobs).as_mut_ptr().offset(i as isize) as *mut IOJob_t; + let job = *((*ctx).completedJobs).as_mut_ptr().offset(i as isize) as *mut IOJob_t; if (*job).offset == (*ctx).waitingOnOffset { (*ctx).completedJobsCount -= 1; let fresh5 = &mut (*((*ctx).completedJobs).as_mut_ptr().offset(i as isize)); @@ -826,9 +819,8 @@ unsafe fn AIO_ReadPool_numReadsInFlight(ctx: *mut ReadPoolCtx_t) -> size_t { - ((*ctx).base.availableJobsCount + (*ctx).completedJobsCount + jobsHeld)) as size_t } unsafe fn AIO_ReadPool_getNextCompletedJob(ctx: *mut ReadPoolCtx_t) -> *mut IOJob_t { - let mut job = core::ptr::null_mut(); AIO_IOPool_lockJobsMutex(&raw mut (*ctx).base); - job = AIO_ReadPool_findNextWaitingOffsetCompletedJob_locked(ctx); + let mut job = AIO_ReadPool_findNextWaitingOffsetCompletedJob_locked(ctx); while job.is_null() && AIO_ReadPool_numReadsInFlight(ctx) > 0 { assert!(!((*ctx).base.threadPool).is_null()); pthread_cond_wait( @@ -1089,7 +1081,6 @@ unsafe fn AIO_ReadPool_releaseCurrentHeldAndGetNext(ctx: *mut ReadPoolCtx_t) -> (*ctx).currentJobHeld as *mut IOJob_t } pub unsafe fn AIO_ReadPool_fillBuffer(ctx: *mut ReadPoolCtx_t, mut n: size_t) -> size_t { - let mut job = core::ptr::null_mut::(); let mut useCoalesce = 0; if n > (*ctx).base.jobBufferSize { n = (*ctx).base.jobBufferSize; @@ -1106,7 +1097,7 @@ pub unsafe fn AIO_ReadPool_fillBuffer(ctx: *mut ReadPoolCtx_t, mut n: size_t) -> ); (*ctx).srcBuffer = (*ctx).coalesceBuffer; } - job = AIO_ReadPool_releaseCurrentHeldAndGetNext(ctx); + let job = AIO_ReadPool_releaseCurrentHeldAndGetNext(ctx); if job.is_null() { return 0; } diff --git a/programs/lorem.rs b/programs/lorem.rs index 5b6899c2..606b9ca0 100644 --- a/programs/lorem.rs +++ b/programs/lorem.rs @@ -274,14 +274,12 @@ unsafe fn countFreqs( ) { let mut total = 0 as core::ffi::c_uint; let mut w: size_t = 0; - w = 0; while w < nbWords { let mut len = (*words.add(w)).to_bytes().len(); - let mut lmax: core::ffi::c_int = 0; if len >= nbWeights { len = nbWeights.wrapping_sub(1); } - lmax = *weights.add(len); + let lmax = *weights.add(len); total = total.wrapping_add(lmax as core::ffi::c_uint); w = w.wrapping_add(1); } @@ -294,19 +292,16 @@ unsafe fn init_word_distrib( weights: *const core::ffi::c_int, nbWeights: size_t, ) { - let mut w: size_t = 0; let mut d = 0 as size_t; countFreqs(words, nbWords, weights, nbWeights); - w = 0; + let mut w: size_t = 0; while w < nbWords { let mut len = (*words.add(w)).to_bytes().len(); - let mut l: core::ffi::c_int = 0; - let mut lmax: core::ffi::c_int = 0; if len >= nbWeights { len = nbWeights.wrapping_sub(1); } - lmax = *weights.add(len); - l = 0; + let lmax = *weights.add(len); + let mut l: core::ffi::c_int = 0; while l < lmax { let fresh0 = d; d = d.wrapping_add(1); @@ -391,7 +386,6 @@ unsafe fn generateSentence(nbWords: core::ffi::c_int) { b". \0" as *const u8 as *const core::ffi::c_char }; let mut i: core::ffi::c_int = 0; - i = 0; while i < nbWords { let wordID = g_distrib[LOREM_rand(g_distribCount) as usize].load(Ordering::Relaxed); let word = kWords[wordID as usize].as_ptr(); @@ -411,7 +405,6 @@ unsafe fn generateSentence(nbWords: core::ffi::c_int) { } unsafe fn generateParagraph(nbSentences: core::ffi::c_int) { let mut i: core::ffi::c_int = 0; - i = 0; while i < nbSentences { let wordsPerSentence = about(11); generateSentence(wordsPerSentence); diff --git a/programs/main.rs b/programs/main.rs index fdfe205f..ff706e21 100644 --- a/programs/main.rs +++ b/programs/main.rs @@ -2,7 +2,6 @@ #![allow(non_camel_case_types)] #![allow(non_snake_case)] #![allow(non_upper_case_globals)] -#![allow(unused_assignments)] // FIXME I guess #![allow(clippy::all)] #![warn(clippy::borrow_as_ptr)] diff --git a/programs/timefn.rs b/programs/timefn.rs index 76c2ee55..105ab453 100644 --- a/programs/timefn.rs +++ b/programs/timefn.rs @@ -36,9 +36,8 @@ pub unsafe fn UTIL_clockSpanNano(clockStart: UTIL_time_t) -> PTime { } pub unsafe fn UTIL_waitForNextTick() { let clockStart = UTIL_getTime(); - let mut clockEnd = UTIL_time_t { t: 0 }; loop { - clockEnd = UTIL_getTime(); + let clockEnd = UTIL_getTime(); if UTIL_getSpanTimeNano(clockStart, clockEnd) != 0 { break; } diff --git a/programs/util.rs b/programs/util.rs index 3d89a8fd..a143c633 100644 --- a/programs/util.rs +++ b/programs/util.rs @@ -1,4 +1,4 @@ -use std::ffi::CStr; +use std::ffi::{c_uint, CStr}; use std::io; #[cfg(target_os = "linux")] @@ -6,10 +6,10 @@ use libc::__errno_location; #[cfg(target_vendor = "apple")] use libc::__error as __errno_location; use libc::{ - calloc, chmod, chown, closedir, dirent, exit, fchmod, fchown, fclose, feof, ferror, fgets, - fileno, fopen, fprintf, fread, free, getchar, isatty, malloc, memcpy, mkdir, mode_t, opendir, - readdir, realloc, size_t, strchr, strcmp, strdup, strlen, strncmp, strrchr, strstr, strtol, - sysconf, timespec, _SC_NPROCESSORS_ONLN, DIR, FILE, + calloc, chmod, chown, closedir, exit, fchmod, fchown, fclose, feof, ferror, fgets, fileno, + fopen, fprintf, fread, free, getchar, isatty, malloc, memcpy, mkdir, mode_t, opendir, readdir, + realloc, size_t, strchr, strcmp, strdup, strlen, strncmp, strrchr, strstr, strtol, sysconf, + timespec, _SC_NPROCESSORS_ONLN, FILE, }; extern "C" { @@ -117,8 +117,6 @@ pub unsafe fn UTIL_requireUserConfirmation( acceptableLetters: *const core::ffi::c_char, hasStdinInput: core::ffi::c_int, ) -> core::ffi::c_int { - let mut ch: core::ffi::c_int = 0; - let mut result: core::ffi::c_int = 0; if hasStdinInput != 0 { fprintf( stderr, @@ -131,8 +129,8 @@ pub unsafe fn UTIL_requireUserConfirmation( b"%s\0" as *const u8 as *const core::ffi::c_char, prompt, ); - ch = getchar(); - result = 0; + let mut ch = getchar(); + let mut result: core::ffi::c_int = 0; if (strchr(acceptableLetters, ch)).is_null() { fprintf( stderr, @@ -156,7 +154,6 @@ pub unsafe fn UTIL_fstat( filename: *const core::ffi::c_char, statbuf: *mut stat_t, ) -> core::ffi::c_int { - let mut ret: core::ffi::c_int = 0; if g_traceFileStat != 0 { fprintf( stderr, @@ -173,11 +170,11 @@ pub unsafe fn UTIL_fstat( fprintf(stderr, b"\n\0" as *const u8 as *const core::ffi::c_char); g_traceDepth += 1; } - if fd >= 0 { - ret = (fstat(fd, statbuf) == 0) as core::ffi::c_int; + let ret = if fd >= 0 { + (fstat(fd, statbuf) == 0) as core::ffi::c_int } else { - ret = (stat(filename, statbuf) == 0) as core::ffi::c_int; - } + (stat(filename, statbuf) == 0) as core::ffi::c_int + }; if g_traceFileStat != 0 { g_traceDepth -= 1; fprintf( @@ -198,7 +195,6 @@ pub unsafe fn UTIL_stat( } pub unsafe fn UTIL_isFdRegularFile(fd: core::ffi::c_int) -> core::ffi::c_int { let mut statbuf = core::mem::zeroed::(); - let mut ret: core::ffi::c_int = 0; if g_traceFileStat != 0 { fprintf( stderr, @@ -214,7 +210,7 @@ pub unsafe fn UTIL_isFdRegularFile(fd: core::ffi::c_int) -> core::ffi::c_int { fprintf(stderr, b"\n\0" as *const u8 as *const core::ffi::c_char); g_traceDepth += 1; } - ret = (fd >= 0 + let ret = (fd >= 0 && UTIL_fstat( fd, b"\0" as *const u8 as *const core::ffi::c_char, @@ -235,7 +231,6 @@ pub unsafe fn UTIL_isFdRegularFile(fd: core::ffi::c_int) -> core::ffi::c_int { } pub unsafe fn UTIL_isRegularFile(infilename: *const core::ffi::c_char) -> core::ffi::c_int { let mut statbuf = core::mem::zeroed::(); - let mut ret: core::ffi::c_int = 0; if g_traceFileStat != 0 { fprintf( stderr, @@ -251,7 +246,7 @@ pub unsafe fn UTIL_isRegularFile(infilename: *const core::ffi::c_char) -> core:: fprintf(stderr, b"\n\0" as *const u8 as *const core::ffi::c_char); g_traceDepth += 1; } - ret = (UTIL_stat(infilename, &raw mut statbuf) != 0 + let ret = (UTIL_stat(infilename, &raw mut statbuf) != 0 && UTIL_isRegularFileStat(&raw const statbuf) != 0) as core::ffi::c_int; if g_traceFileStat != 0 { g_traceDepth -= 1; @@ -330,7 +325,6 @@ pub unsafe fn UTIL_fchmod( return 0; } if fd >= 0 { - let mut ret: core::ffi::c_int = 0; if g_traceFileStat != 0 { fprintf( stderr, @@ -342,7 +336,7 @@ pub unsafe fn UTIL_fchmod( fprintf(stderr, b"\n\0" as *const u8 as *const core::ffi::c_char); g_traceDepth += 1; } - ret = fchmod(fd, permissions); + let ret = fchmod(fd, permissions); if g_traceFileStat != 0 { g_traceDepth -= 1; fprintf( @@ -365,7 +359,6 @@ pub unsafe fn UTIL_fchmod( } ret } else { - let mut ret_0: core::ffi::c_int = 0; if g_traceFileStat != 0 { fprintf( stderr, @@ -377,7 +370,7 @@ pub unsafe fn UTIL_fchmod( fprintf(stderr, b"\n\0" as *const u8 as *const core::ffi::c_char); g_traceDepth += 1; } - ret_0 = chmod(filename, permissions); + let ret_0 = chmod(filename, permissions); if g_traceFileStat != 0 { g_traceDepth -= 1; fprintf( @@ -405,7 +398,6 @@ pub unsafe fn UTIL_utime( filename: *const core::ffi::c_char, statbuf: *const stat_t, ) -> core::ffi::c_int { - let mut ret: core::ffi::c_int = 0; if g_traceFileStat != 0 { fprintf( stderr, @@ -428,7 +420,7 @@ pub unsafe fn UTIL_utime( } }; 2]; *timebuf.as_mut_ptr().offset(1) = (*statbuf).st_mtim; - ret = utimensat( + let ret = utimensat( AT_FDCWD, filename, timebuf.as_mut_ptr() as *const timespec, @@ -580,7 +572,6 @@ pub unsafe fn UTIL_isDirectory(infilename: *const core::ffi::c_char) -> core::ff }, __glibc_reserved: [0; 3], }; - let mut ret: core::ffi::c_int = 0; if g_traceFileStat != 0 { fprintf( stderr, @@ -596,7 +587,7 @@ pub unsafe fn UTIL_isDirectory(infilename: *const core::ffi::c_char) -> core::ff fprintf(stderr, b"\n\0" as *const u8 as *const core::ffi::c_char); g_traceDepth += 1; } - ret = (UTIL_stat(infilename, &raw mut statbuf) != 0 + let ret = (UTIL_stat(infilename, &raw mut statbuf) != 0 && UTIL_isDirectoryStat(&raw const statbuf) != 0) as core::ffi::c_int; if g_traceFileStat != 0 { g_traceDepth -= 1; @@ -611,7 +602,6 @@ pub unsafe fn UTIL_isDirectory(infilename: *const core::ffi::c_char) -> core::ff ret } pub unsafe fn UTIL_isDirectoryStat(statbuf: *const stat_t) -> core::ffi::c_int { - let mut ret: core::ffi::c_int = 0; if g_traceFileStat != 0 { fprintf( stderr, @@ -626,8 +616,8 @@ pub unsafe fn UTIL_isDirectoryStat(statbuf: *const stat_t) -> core::ffi::c_int { fprintf(stderr, b"\n\0" as *const u8 as *const core::ffi::c_char); g_traceDepth += 1; } - ret = (((*statbuf).st_mode & __S_IFMT as __mode_t == 0o40000 as core::ffi::c_int as __mode_t) - as core::ffi::c_int + let ret = (((*statbuf).st_mode & __S_IFMT as __mode_t + == 0o40000 as core::ffi::c_int as __mode_t) as core::ffi::c_int != 0) as core::ffi::c_int; if g_traceFileStat != 0 { g_traceDepth -= 1; @@ -654,7 +644,6 @@ pub unsafe fn UTIL_isSameFile( fName1: *const core::ffi::c_char, fName2: *const core::ffi::c_char, ) -> core::ffi::c_int { - let mut ret: core::ffi::c_int = 0; assert!(!fName1.is_null()); assert!(!fName2.is_null()); if g_traceFileStat != 0 { @@ -725,7 +714,7 @@ pub unsafe fn UTIL_isSameFile( }, __glibc_reserved: [0; 3], }; - ret = (UTIL_stat(fName1, &raw mut file1Stat) != 0 + let ret = (UTIL_stat(fName1, &raw mut file1Stat) != 0 && UTIL_stat(fName2, &raw mut file2Stat) != 0 && UTIL_isSameFileStat(fName1, fName2, &raw const file1Stat, &raw const file2Stat) != 0) as core::ffi::c_int; @@ -747,7 +736,6 @@ pub unsafe fn UTIL_isSameFileStat( file1Stat: *const stat_t, file2Stat: *const stat_t, ) -> core::ffi::c_int { - let mut ret: core::ffi::c_int = 0; assert!(!fName1.is_null()); assert!(!fName2.is_null()); if g_traceFileStat != 0 { @@ -766,8 +754,8 @@ pub unsafe fn UTIL_isSameFileStat( fprintf(stderr, b"\n\0" as *const u8 as *const core::ffi::c_char); g_traceDepth += 1; } - ret = ((*file1Stat).st_dev == (*file2Stat).st_dev && (*file1Stat).st_ino == (*file2Stat).st_ino) - as core::ffi::c_int; + let ret = ((*file1Stat).st_dev == (*file2Stat).st_dev + && (*file1Stat).st_ino == (*file2Stat).st_ino) as core::ffi::c_int; if g_traceFileStat != 0 { g_traceDepth -= 1; fprintf( @@ -998,7 +986,6 @@ static mut g_fakeStdinIsConsole: core::ffi::c_int = 0; static mut g_fakeStderrIsConsole: core::ffi::c_int = 0; static mut g_fakeStdoutIsConsole: core::ffi::c_int = 0; pub unsafe fn UTIL_isConsole(file: *mut FILE) -> core::ffi::c_int { - let mut ret: core::ffi::c_int = 0; if g_traceFileStat != 0 { fprintf( stderr, @@ -1014,14 +1001,14 @@ pub unsafe fn UTIL_isConsole(file: *mut FILE) -> core::ffi::c_int { fprintf(stderr, b"\n\0" as *const u8 as *const core::ffi::c_char); g_traceDepth += 1; } - if (file == stdin && g_fakeStdinIsConsole != 0) + let ret = if (file == stdin && g_fakeStdinIsConsole != 0) || (file == stderr && g_fakeStderrIsConsole != 0) || (file == stdout && g_fakeStdoutIsConsole != 0) { - ret = 1; + 1 } else { - ret = isatty(fileno(file)); - } + isatty(fileno(file)) + }; if g_traceFileStat != 0 { g_traceDepth -= 1; fprintf( @@ -1185,7 +1172,6 @@ pub unsafe fn UTIL_getTotalFileSize( nbFiles: core::ffi::c_uint, ) -> u64 { let mut total = 0u64; - let mut n: core::ffi::c_uint = 0; if g_traceFileStat != 0 { fprintf( stderr, @@ -1201,7 +1187,7 @@ pub unsafe fn UTIL_getTotalFileSize( fprintf(stderr, b"\n\0" as *const u8 as *const core::ffi::c_char); g_traceDepth += 1; } - n = 0; + let mut n: core::ffi::c_uint = 0; while n < nbFiles { let size = UTIL_getFileSize(*fileNamesTable.offset(n as isize)); if size == UTIL_FILESIZE_UNKNOWN as u64 { @@ -1238,13 +1224,12 @@ unsafe fn UTIL_readFileContent( ) -> *mut core::ffi::c_char { let mut bufSize = (64 * ((1) << 10)) as size_t; let mut totalRead = 0; - let mut bytesRead = 0; let mut buf = malloc(bufSize) as *mut core::ffi::c_char; if buf.is_null() { return core::ptr::null_mut(); } loop { - bytesRead = fread( + let bytesRead = fread( buf.add(totalRead) as *mut core::ffi::c_void, 1, bufSize.wrapping_sub(totalRead).wrapping_sub(1), @@ -1357,8 +1342,6 @@ pub unsafe fn UTIL_createFileNamesTable_fromFileList( }, __glibc_reserved: [0; 3], }; - let mut buffer = core::ptr::null_mut(); - let mut numLines = 0; let mut bufferSize = 0; if UTIL_stat(fileList, &raw mut statbuf) == 0 { return core::ptr::null_mut(); @@ -1373,12 +1356,12 @@ pub unsafe fn UTIL_createFileNamesTable_fromFileList( if inFile.is_null() { return core::ptr::null_mut(); } - buffer = UTIL_readFileContent(inFile, &raw mut bufferSize); + let buffer = UTIL_readFileContent(inFile, &raw mut bufferSize); fclose(inFile); if buffer.is_null() { return core::ptr::null_mut(); } - numLines = UTIL_processLines(buffer, bufferSize); + let numLines = UTIL_processLines(buffer, bufferSize); if numLines == 0 { free(buffer as *mut core::ffi::c_void); return core::ptr::null_mut(); @@ -1433,11 +1416,10 @@ pub unsafe fn UTIL_freeFileNamesTable(table: *mut FileNamesTable) { pub unsafe fn UTIL_allocateFileNamesTable(tableSize: size_t) -> *mut FileNamesTable { let fnTable = malloc(tableSize.wrapping_mul(size_of::<*const core::ffi::c_char>())) as *mut *const core::ffi::c_char; - let mut fnt = core::ptr::null_mut::(); if fnTable.is_null() { return core::ptr::null_mut(); } - fnt = UTIL_assembleFileNamesTable(fnTable, tableSize, core::ptr::null_mut()); + let fnt = UTIL_assembleFileNamesTable(fnTable, tableSize, core::ptr::null_mut()); (*fnt).tableSize = 0; fnt } @@ -1446,7 +1428,6 @@ pub unsafe fn UTIL_searchFileNamesTable( name: *const core::ffi::c_char, ) -> core::ffi::c_int { let mut i: size_t = 0; - i = 0; while i < (*table).tableSize { if strcmp(*((*table).fileNames).add(i), name) == 0 { return i as core::ffi::c_int; @@ -1464,7 +1445,6 @@ pub unsafe fn UTIL_refFilename(fnt: *mut FileNamesTable, filename: *const core:: unsafe fn getTotalTableSize(table: *mut FileNamesTable) -> size_t { let mut fnb: size_t = 0; let mut totalSize = 0 as size_t; - fnb = 0; while fnb < (*table).tableSize && !(*((*table).fileNames).add(fnb)).is_null() { totalSize = totalSize.wrapping_add((strlen(*((*table).fileNames).add(fnb))).wrapping_add(1)); @@ -1478,8 +1458,6 @@ pub unsafe fn UTIL_mergeFileNamesTable( ) -> *mut FileNamesTable { let mut newTableIdx = 0 as core::ffi::c_uint; let mut pos = 0; - let mut newTotalTableSize: size_t = 0; - let mut buf = core::ptr::null_mut::(); let newTable = UTIL_assembleFileNamesTable(core::ptr::null_mut(), 0, core::ptr::null_mut()); if newTable.is_null() { if g_utilDisplayLevel >= 1 { @@ -1493,8 +1471,8 @@ pub unsafe fn UTIL_mergeFileNamesTable( } exit(1); } - newTotalTableSize = (getTotalTableSize(table1)).wrapping_add(getTotalTableSize(table2)); - buf = calloc(newTotalTableSize, size_of::()) as *mut core::ffi::c_char; + let newTotalTableSize = (getTotalTableSize(table1)).wrapping_add(getTotalTableSize(table2)); + let buf = calloc(newTotalTableSize, size_of::()) as *mut core::ffi::c_char; if buf.is_null() { if g_utilDisplayLevel >= 1 { fprintf( @@ -1524,7 +1502,6 @@ pub unsafe fn UTIL_mergeFileNamesTable( exit(1); } let mut idx1: core::ffi::c_uint = 0; - idx1 = 0; while (idx1 as size_t) < (*table1).tableSize && !(*((*table1).fileNames).offset(idx1 as isize)).is_null() && pos < newTotalTableSize @@ -1543,7 +1520,6 @@ pub unsafe fn UTIL_mergeFileNamesTable( newTableIdx = newTableIdx.wrapping_add(1); } let mut idx2: core::ffi::c_uint = 0; - idx2 = 0; while (idx2 as size_t) < (*table2).tableSize && !(*((*table2).fileNames).offset(idx2 as isize)).is_null() && pos < newTotalTableSize @@ -1574,11 +1550,8 @@ unsafe fn UTIL_prepareFileList( bufEnd: *mut *mut core::ffi::c_char, followLinks: core::ffi::c_int, ) -> core::ffi::c_int { - let mut dir = core::ptr::null_mut::(); - let mut entry = core::ptr::null_mut::(); - let mut dirLength: size_t = 0; let mut nbFiles = 0; - dir = opendir(dirName); + let dir = opendir(dirName); if dir.is_null() { if g_utilDisplayLevel >= 1 { eprintln!( @@ -1589,16 +1562,13 @@ unsafe fn UTIL_prepareFileList( } return 0; } - dirLength = strlen(dirName); + let dirLength = strlen(dirName); *__errno_location() = 0; loop { - entry = readdir(dir); + let entry = readdir(dir); if entry.is_null() { break; } - let mut path = core::ptr::null_mut::(); - let mut fnameLength: size_t = 0; - let mut pathLength: size_t = 0; if strcmp( ((*entry).d_name).as_mut_ptr(), b"..\0" as *const u8 as *const core::ffi::c_char, @@ -1610,8 +1580,8 @@ unsafe fn UTIL_prepareFileList( { continue; } - fnameLength = strlen(((*entry).d_name).as_mut_ptr()); - path = + let fnameLength = strlen(((*entry).d_name).as_mut_ptr()); + let path = malloc(dirLength.wrapping_add(fnameLength).wrapping_add(2)) as *mut core::ffi::c_char; if path.is_null() { closedir(dir); @@ -1628,7 +1598,7 @@ unsafe fn UTIL_prepareFileList( ((*entry).d_name).as_mut_ptr() as *const core::ffi::c_void, fnameLength, ); - pathLength = dirLength.wrapping_add(1).wrapping_add(fnameLength); + let pathLength = dirLength.wrapping_add(1).wrapping_add(fnameLength); *path.add(pathLength) = 0; if followLinks == 0 && UTIL_isLink(path) != 0 { if g_utilDisplayLevel >= 2 { @@ -1794,10 +1764,8 @@ unsafe fn makeDir(dir: *const core::ffi::c_char, mode: mode_t) -> core::ffi::c_i ret } unsafe fn convertPathnameToDirName(pathname: *mut core::ffi::c_char) { - let mut len = 0; - let mut pos = core::ptr::null_mut(); assert!(!pathname.is_null()); - len = strlen(pathname); + let mut len = strlen(pathname); assert!(len > 0); while *pathname.add(len) as core::ffi::c_int == PATH_SEP { *pathname.add(len) = 0; @@ -1806,7 +1774,7 @@ unsafe fn convertPathnameToDirName(pathname: *mut core::ffi::c_char) { if len == 0 { return; } - pos = strrchr(pathname, PATH_SEP); + let pos = strrchr(pathname, PATH_SEP); if pos.is_null() { *pathname.offset(0) = '.' as i32 as core::ffi::c_char; *pathname.offset(1) = '\0' as i32 as core::ffi::c_char; @@ -1849,9 +1817,7 @@ unsafe fn mallocAndJoin2Dir( assert!(!dir1.is_null() && !dir2.is_null()); let dir1Size = strlen(dir1); let dir2Size = strlen(dir2); - let mut outDirBuffer = core::ptr::null_mut::(); - let mut buffer = core::ptr::null_mut::(); - outDirBuffer = + let outDirBuffer = malloc(dir1Size.wrapping_add(dir2Size).wrapping_add(2)) as *mut core::ffi::c_char; if outDirBuffer.is_null() { if g_utilDisplayLevel >= 1 { @@ -1871,7 +1837,7 @@ unsafe fn mallocAndJoin2Dir( dir1Size, ); *outDirBuffer.add(dir1Size) = 0; - buffer = outDirBuffer.add(dir1Size); + let mut buffer = outDirBuffer.add(dir1Size); if dir1Size > 0 && *buffer.offset(-(1)) as core::ffi::c_int != PATH_SEP { *buffer = PATH_SEP as core::ffi::c_char; buffer = buffer.offset(1); @@ -1888,11 +1854,10 @@ pub unsafe fn UTIL_createMirroredDestDirName( srcFileName: *const core::ffi::c_char, outDirRootName: *const core::ffi::c_char, ) -> *mut core::ffi::c_char { - let mut pathname = core::ptr::null_mut(); if isFileNameValidForMirroredOutput(srcFileName) == 0 { return core::ptr::null_mut(); } - pathname = mallocAndJoin2Dir(outDirRootName, trimPath(srcFileName)); + let pathname = mallocAndJoin2Dir(outDirRootName, trimPath(srcFileName)); convertPathnameToDirName(pathname); pathname } @@ -1900,14 +1865,12 @@ unsafe fn mirrorSrcDir( srcDirName: *mut core::ffi::c_char, outDirName: *const core::ffi::c_char, ) -> core::ffi::c_int { - let mut srcMode: mode_t = 0; - let mut status = 0; let newDir = mallocAndJoin2Dir(outDirName, trimPath(srcDirName)); if newDir.is_null() { return -ENOMEM; } - srcMode = getDirMode(srcDirName); - status = makeDir(newDir, srcMode); + let srcMode = getDirMode(srcDirName); + let status = makeDir(newDir, srcMode); free(newDir as *mut core::ffi::c_void); status } @@ -1915,17 +1878,15 @@ unsafe fn mirrorSrcDirRecursive( srcDirName: *mut core::ffi::c_char, outDirName: *const core::ffi::c_char, ) -> core::ffi::c_int { - let mut status = 0; let mut pp = trimLeadingCurrentDir(srcDirName); - let mut sp = core::ptr::null_mut(); loop { - sp = strchr(pp, PATH_SEP); + let sp = strchr(pp, PATH_SEP); if sp.is_null() { break; } if sp != pp { *sp = '\0' as i32 as core::ffi::c_char; - status = mirrorSrcDir(srcDirName, outDirName); + let status = mirrorSrcDir(srcDirName, outDirName); if status != 0 { return status; } @@ -1933,8 +1894,7 @@ unsafe fn mirrorSrcDirRecursive( } pp = sp.offset(1); } - status = mirrorSrcDir(srcDirName, outDirName); - status + mirrorSrcDir(srcDirName, outDirName) } unsafe fn makeMirroredDestDirsWithSameSrcDirMode( srcDirNames: *mut *mut core::ffi::c_char, @@ -1942,7 +1902,6 @@ unsafe fn makeMirroredDestDirsWithSameSrcDirMode( outDirName: *const core::ffi::c_char, ) { let mut i = 0; - i = 0; while i < nbFile { mirrorSrcDirRecursive(*srcDirNames.offset(i as isize), outDirName); i = i.wrapping_add(1); @@ -1972,14 +1931,12 @@ unsafe fn makeUniqueMirroredDestDirs( nbFile: core::ffi::c_uint, outDirName: *const core::ffi::c_char, ) { - let mut i = 0; - let mut uniqueDirNr = 0 as core::ffi::c_uint; - let mut uniqueDirNames = core::ptr::null_mut(); if nbFile == 0 { return; } - uniqueDirNames = malloc((nbFile as size_t).wrapping_mul(size_of::<*mut core::ffi::c_char>())) - as *mut *mut core::ffi::c_char; + let uniqueDirNames = + malloc((nbFile as size_t).wrapping_mul(size_of::<*mut core::ffi::c_char>())) + as *mut *mut core::ffi::c_char; if uniqueDirNames.is_null() { if g_utilDisplayLevel >= 1 { fprintf( @@ -2004,10 +1961,10 @@ unsafe fn makeUniqueMirroredDestDirs( ) -> core::ffi::c_int, ), ); - uniqueDirNr = 1; + let mut uniqueDirNr: c_uint = 1; let fresh5 = &mut (*uniqueDirNames.offset(uniqueDirNr.wrapping_sub(1) as isize)); *fresh5 = *srcDirNames.offset(0); - i = 1; + let mut i = 0; while i < nbFile { let prevDirName = *srcDirNames.offset(i.wrapping_sub(1) as isize); let currDirName = *srcDirNames.offset(i as isize); @@ -2027,7 +1984,6 @@ unsafe fn makeMirroredDestDirs( outDirName: *const core::ffi::c_char, ) { let mut i = 0; - i = 0; while i < nbFile { convertPathnameToDirName(*srcFileNames.offset(i as isize)); i = i.wrapping_add(1); @@ -2039,7 +1995,6 @@ pub unsafe fn UTIL_mirrorSourceFilesDirectories( nbFile: core::ffi::c_uint, outDirName: *const core::ffi::c_char, ) { - let mut i = 0; let mut validFilenamesNr = 0 as core::ffi::c_uint; let srcFileNames = malloc((nbFile as size_t).wrapping_mul(size_of::<*mut core::ffi::c_char>())) as *mut *mut core::ffi::c_char; @@ -2055,7 +2010,7 @@ pub unsafe fn UTIL_mirrorSourceFilesDirectories( } exit(1); } - i = 0; + let mut i = 0; while i < nbFile { if isFileNameValidForMirroredOutput(*inFileNames.offset(i as isize)) != 0 { let fname = strdup(*inFileNames.offset(i as isize)); @@ -2102,9 +2057,6 @@ pub unsafe fn UTIL_createExpandedFNT( } let mut ifnNb: size_t = 0; let mut pos: size_t = 0; - ifnNb = 0; - pos = 0; - nbFiles = 0; while ifnNb < nbIfns { if UTIL_isDirectory(*inputNames.add(ifnNb)) == 0 { let len = strlen(*inputNames.add(ifnNb)); @@ -2151,8 +2103,6 @@ pub unsafe fn UTIL_createExpandedFNT( free(buf as *mut core::ffi::c_void); return core::ptr::null_mut(); } - ifnNb_0 = 0; - pos_0 = 0; while ifnNb_0 < nbFiles as size_t { let fresh9 = &mut (*fileNamesTable.add(ifnNb_0)); *fresh9 = buf.add(pos_0); diff --git a/programs/zstdcli.rs b/programs/zstdcli.rs index f6dcb161..ae806f57 100644 --- a/programs/zstdcli.rs +++ b/programs/zstdcli.rs @@ -1715,12 +1715,10 @@ unsafe fn main_0( argCount: core::ffi::c_int, argv: *mut *const core::ffi::c_char, ) -> core::ffi::c_int { - let mut argNb: core::ffi::c_int = 0; let mut followLinks = 0; let mut allowBlockDevices = 0; let mut forceStdin = 0; let mut forceStdout = 0; - let mut hasStdout = 0; let mut ldmFlag = 0; let mut main_pause = 0; let mut adapt = 0; @@ -1776,7 +1774,6 @@ unsafe fn main_0( let mut streamSrcSize = 0; let mut targetCBlockSize = 0; let mut srcSizeHint = 0; - let mut nbInputFileNames = 0; let mut dictCLevel = g_defaultDictCLevel; let mut dictSelect = g_defaultSelectivityLevel; let mut coverParams = defaultCoverParams(); @@ -1875,7 +1872,7 @@ unsafe fn main_0( size_of::(), ); FIO_addAbortHandler(); - argNb = 1; + let mut argNb = 1; 'end: { loop { @@ -1887,6 +1884,7 @@ unsafe fn main_0( macro_rules! NEXT_FIELD { ($ptr:ident) => { + #[allow(unused_assignments)] if *argument as u8 == b'=' { argument = argument.offset(1); $ptr = argument; @@ -2555,19 +2553,18 @@ unsafe fn main_0( b"--long\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - let mut ldmWindowLog = 0; ldmFlag = 1; ultra = 1; - if *argument as core::ffi::c_int == '=' as i32 { + let ldmWindowLog = if *argument as core::ffi::c_int == '=' as i32 { argument = argument.offset(1); - ldmWindowLog = readU32FromChar(&raw mut argument); + readU32FromChar(&raw mut argument) } else if *argument as core::ffi::c_int != 0 { badUsage(programName, originalArgument); operationResult = 1; break 'end; } else { - ldmWindowLog = g_defaultMaxWindowLog; - } + g_defaultMaxWindowLog + }; if compressionParams.windowLog == 0 { compressionParams.windowLog = ldmWindowLog; } @@ -2578,9 +2575,8 @@ unsafe fn main_0( { if *argument as core::ffi::c_int == '=' as i32 { let maxFast = -ZSTD_minCLevel() as u32; - let mut fastLevel: u32 = 0; argument = argument.offset(1); - fastLevel = readU32FromChar(&raw mut argument); + let mut fastLevel = readU32FromChar(&raw mut argument); if fastLevel > maxFast { fastLevel = maxFast; } @@ -2604,7 +2600,7 @@ unsafe fn main_0( b"--filelist\0" as *const u8 as *const core::ffi::c_char, ) != 0 { - let mut listName = core::ptr::null::(); + let listName; NEXT_FIELD!(listName); UTIL_refFilename(file_of_names, listName); } else { @@ -2833,8 +2829,6 @@ unsafe fn main_0( let mut u: core::ffi::c_uint = 0; let mut fileNamesNb: core::ffi::c_uint = 0; let nbFilenames = (*filenames).tableSize as core::ffi::c_uint; - u = 0; - fileNamesNb = 0; while u < nbFilenames { if UTIL_isLink(*((*filenames).fileNames).offset(u as isize)) != 0 && UTIL_isFIFO(*((*filenames).fileNames).offset(u as isize)) == 0 @@ -2865,7 +2859,6 @@ unsafe fn main_0( if (*file_of_names).tableSize != 0 { let nbFileLists = (*file_of_names).tableSize; let mut flNb: size_t = 0; - flNb = 0; loop { if flNb >= nbFileLists { break; @@ -2888,7 +2881,7 @@ unsafe fn main_0( } } } - nbInputFileNames = (*filenames).tableSize; + let nbInputFileNames = (*filenames).tableSize; if recursive != 0 { UTIL_expandFNT(&raw mut filenames, followLinks); } @@ -2984,7 +2977,6 @@ unsafe fn main_0( if (*filenames).tableSize > 0 { if separateFiles != 0 { let mut i: core::ffi::c_uint = 0; - i = 0; while (i as size_t) < (*filenames).tableSize { operationResult = BMK_benchFilesAdvanced( &raw const *((*filenames).fileNames).offset(i as isize), @@ -3189,7 +3181,7 @@ unsafe fn main_0( } operationResult = 1; } else { - hasStdout = (!outFileName.is_null() + let hasStdout = (!outFileName.is_null() && strcmp(outFileName, stdoutmark.as_ptr()) == 0) as core::ffi::c_int; if hasStdout != 0 && g_displayLevel == 2 { @@ -3277,7 +3269,6 @@ unsafe fn main_0( ); if showDefaultCParams != 0 || g_displayLevel >= 4 { let mut fileNb: size_t = 0; - fileNb = 0; while fileNb < (*filenames).tableSize { if showDefaultCParams != 0 { printDefaultCParams( From a7585e5fb9161e1fad94b11a6d337ab3aa8217b0 Mon Sep 17 00:00:00 2001 From: Mattias Wallin Date: Sat, 6 Jun 2026 17:21:56 +0200 Subject: [PATCH 15/16] Fix: clippy::ptr_offset_by_literal --- Cargo.toml | 3 + programs/benchzstd.rs | 4 +- programs/datagen.rs | 2 +- programs/fileio.rs | 40 +++---- programs/fileio_asyncio.rs | 2 +- programs/util.rs | 42 +++---- programs/zstdcli.rs | 228 ++++++++++++++++++------------------- 7 files changed, 160 insertions(+), 161 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 4785d919..01e23f26 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -26,6 +26,9 @@ include = [ "lib/decompress/huf_decompress_amd64.S", ] +[lints.clippy] +ptr_offset_by_literal = "warn" + [lib] name = "libzstd_rs_sys" path = "c2rust-lib.rs" diff --git a/programs/benchzstd.rs b/programs/benchzstd.rs index ac2e7df2..8790a8b5 100644 --- a/programs/benchzstd.rs +++ b/programs/benchzstd.rs @@ -1718,7 +1718,7 @@ unsafe fn BMK_benchCLevels( pch = strrchr(displayName, '/' as i32); } if !pch.is_null() { - displayName = pch.offset(1); + displayName = pch.add(1); } if endCLevel > ZSTD_maxCLevel() { if displayLevel >= 1 { @@ -2145,7 +2145,7 @@ pub unsafe fn BMK_benchFilesAdvanced( let displayName = if nbFiles > 1 { mfName.as_mut_ptr() as *const core::ffi::c_char } else { - *fileNamesTable.offset(0) + *fileNamesTable }; res = BMK_benchCLevels( srcBuffer, diff --git a/programs/datagen.rs b/programs/datagen.rs index 9b23f83b..42f037ff 100644 --- a/programs/datagen.rs +++ b/programs/datagen.rs @@ -95,7 +95,7 @@ unsafe fn RDG_genBlock( } } if pos == 0 { - *buffPtr.offset(0) = RDG_genChar(seedPtr, ldt); + *buffPtr = RDG_genChar(seedPtr, ldt); pos = 1; } while pos < buffSize { diff --git a/programs/fileio.rs b/programs/fileio.rs index cd1aef88..d2ed37aa 100644 --- a/programs/fileio.rs +++ b/programs/fileio.rs @@ -1370,7 +1370,7 @@ pub unsafe fn FIO_checkFilenameCollisions( *fresh0 = *filenameTable.offset(u as isize); } else { let fresh1 = &mut (*filenameTableSorted.offset(u as isize)); - *fresh1 = filename.offset(1); + *fresh1 = filename.add(1); } u = u.wrapping_add(1); } @@ -1386,7 +1386,7 @@ pub unsafe fn FIO_checkFilenameCollisions( ) -> core::ffi::c_int, ), ); - let mut prevElem = *filenameTableSorted.offset(0); + let mut prevElem = *filenameTableSorted; u = 1; while u < nbFiles { if strcmp(prevElem, *filenameTableSorted.offset(u as isize)) == 0 @@ -1413,7 +1413,7 @@ unsafe fn extractFilename( if search.is_null() { return path; } - search.offset(1) + search.add(1) } unsafe fn FIO_createFilename_fromOutDir( path: *const core::ffi::c_char, @@ -1477,7 +1477,7 @@ unsafe fn FIO_createFilename_fromOutDir( 1, ); memcpy( - result.add(strlen(outDirName)).offset(1) as *mut core::ffi::c_void, + result.add(strlen(outDirName)).add(1) as *mut core::ffi::c_void, filenameStart as *const core::ffi::c_void, strlen(filenameStart), ); @@ -4282,8 +4282,7 @@ unsafe fn FIO_compressZstdFrame( if (*fCtx).nbFilesTotal > 1 { let srcFileNameSize = strlen(srcFileName); if srcFileNameSize > 18 { - let truncatedSrcFileName = - srcFileName.add(srcFileNameSize).offset(-(15)); + let truncatedSrcFileName = srcFileName.add(srcFileNameSize).sub(15); if g_display_prefs.progressSetting as core::ffi::c_uint != FIO_ps_never as core::ffi::c_int as core::ffi::c_uint && (g_display_prefs.displayLevel >= 2 @@ -6224,24 +6223,21 @@ unsafe fn FIO_decompressFrames( return 1; } filesize = filesize.wrapping_add(frameSize); - } else if *buf.offset(0) as core::ffi::c_int == 31 - && *buf.offset(1) as core::ffi::c_int == 139 - { + } else if *buf as core::ffi::c_int == 31 && *buf.add(1) as core::ffi::c_int == 139 { let frameSize_0 = FIO_decompressGzFrame(&raw mut ress, srcFileName); if frameSize_0 == FIO_ERROR_FRAME_DECODING as core::ffi::c_ulonglong { return 1; } filesize = filesize.wrapping_add(frameSize_0); - } else if *buf.offset(0) as core::ffi::c_int == 0xfd as core::ffi::c_int - && *buf.offset(1) as core::ffi::c_int == 0x37 as core::ffi::c_int - || *buf.offset(0) as core::ffi::c_int == 0x5d as core::ffi::c_int - && *buf.offset(1) as core::ffi::c_int == 0 + } else if *buf as core::ffi::c_int == 0xfd as core::ffi::c_int + && *buf.add(1) as core::ffi::c_int == 0x37 as core::ffi::c_int + || *buf as core::ffi::c_int == 0x5d as core::ffi::c_int + && *buf.add(1) as core::ffi::c_int == 0 { let frameSize_1 = FIO_decompressLzmaFrame( &raw mut ress, srcFileName, - (*buf.offset(0) as core::ffi::c_int != 0xfd as core::ffi::c_int) - as core::ffi::c_int, + (*buf as core::ffi::c_int != 0xfd as core::ffi::c_int) as core::ffi::c_int, ); if frameSize_1 == FIO_ERROR_FRAME_DECODING as core::ffi::c_ulonglong { return 1; @@ -6513,7 +6509,7 @@ unsafe fn FIO_determineDstName( } return core::ptr::null(); } - if *matchedSuffix.unwrap().as_ptr().offset(1) as core::ffi::c_int == 't' as i32 { + if *matchedSuffix.unwrap().as_ptr().add(1) as core::ffi::c_int == 't' as i32 { dstSuffix = b".tar\0" as *const u8 as *const core::ffi::c_char; dstSuffixLen = strlen(dstSuffix); } @@ -6960,7 +6956,7 @@ unsafe fn FIO_analyzeFrames(info: *mut fileInfo_t, srcFile: *mut FILE) -> InfoEr break; } } - let frameHeaderDescriptor = *headerBuffer.as_mut_ptr().offset(4); + let frameHeaderDescriptor = *headerBuffer.as_mut_ptr().add(4); let contentChecksumFlag = (frameHeaderDescriptor as core::ffi::c_int & (1) << 2) >> 2; if contentChecksumFlag != 0 { @@ -6988,7 +6984,7 @@ unsafe fn FIO_analyzeFrames(info: *mut fileInfo_t, srcFile: *mut FILE) -> InfoEr (*info).numActualFrames += 1; } else if magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK == ZSTD_MAGIC_SKIPPABLE_START { let frameSize = - MEM_readLE32(headerBuffer.as_mut_ptr().offset(4) as *const core::ffi::c_void); + MEM_readLE32(headerBuffer.as_mut_ptr().add(4) as *const core::ffi::c_void); let seek = (8u32.wrapping_add(frameSize) as size_t).wrapping_sub(numBytesRead) as core::ffi::c_long; if fseek(srcFile, seek, 1) != 0 { @@ -7188,10 +7184,10 @@ unsafe fn displayInfo( stdout, b"Check: %s %02x%02x%02x%02x\n\0" as *const u8 as *const core::ffi::c_char, checkString, - *((*info).checksum).as_ptr().offset(3) as core::ffi::c_int, - *((*info).checksum).as_ptr().offset(2) as core::ffi::c_int, - *((*info).checksum).as_ptr().offset(1) as core::ffi::c_int, - *((*info).checksum).as_ptr().offset(0) as core::ffi::c_int, + *((*info).checksum).as_ptr().add(3) as core::ffi::c_int, + *((*info).checksum).as_ptr().add(2) as core::ffi::c_int, + *((*info).checksum).as_ptr().add(1) as core::ffi::c_int, + *((*info).checksum).as_ptr() as core::ffi::c_int, ); } else { fprintf( diff --git a/programs/fileio_asyncio.rs b/programs/fileio_asyncio.rs index 120fbdd9..ebef487a 100644 --- a/programs/fileio_asyncio.rs +++ b/programs/fileio_asyncio.rs @@ -295,7 +295,7 @@ unsafe fn AIO_fwriteSparse( let restEnd = (buffer as *const core::ffi::c_char).add(bufferSize); assert!(restEnd > restStart && restEnd < restStart.add(size_of::())); while restPtr < restEnd && *restPtr as core::ffi::c_int == 0 { - restPtr = restPtr.offset(1); + restPtr = restPtr.add(1); } storedSkips = storedSkips .wrapping_add(restPtr.offset_from(restStart) as core::ffi::c_long as core::ffi::c_uint); diff --git a/programs/util.rs b/programs/util.rs index a143c633..3c9af31e 100644 --- a/programs/util.rs +++ b/programs/util.rs @@ -419,7 +419,7 @@ pub unsafe fn UTIL_utime( tv_nsec: UTIME_NOW, } }; 2]; - *timebuf.as_mut_ptr().offset(1) = (*statbuf).st_mtim; + *timebuf.as_mut_ptr().add(1) = (*statbuf).st_mtim; let ret = utimensat( AT_FDCWD, filename, @@ -857,7 +857,7 @@ pub unsafe fn UTIL_isFileDescriptorPipe(filename: *const core::ffi::c_char) -> c fprintf(stderr, b"\n\0" as *const u8 as *const core::ffi::c_char); g_traceDepth += 1; } - if *filename.offset(0) as core::ffi::c_int == '/' as i32 + if *filename as core::ffi::c_int == '/' as i32 && strncmp( filename, b"/dev/fd/\0" as *const u8 as *const core::ffi::c_char, @@ -876,7 +876,7 @@ pub unsafe fn UTIL_isFileDescriptorPipe(filename: *const core::ffi::c_char) -> c } return 1; } - if *filename.offset(0) as core::ffi::c_int == '/' as i32 + if *filename as core::ffi::c_int == '/' as i32 && strncmp( filename, b"/proc/self/fd/\0" as *const u8 as *const core::ffi::c_char, @@ -1594,7 +1594,7 @@ unsafe fn UTIL_prepareFileList( ); *path.add(dirLength) = '/' as i32 as core::ffi::c_char; memcpy( - path.add(dirLength).offset(1) as *mut core::ffi::c_void, + path.add(dirLength).add(1) as *mut core::ffi::c_void, ((*entry).d_name).as_mut_ptr() as *const core::ffi::c_void, fnameLength, ); @@ -1691,13 +1691,13 @@ unsafe fn pathnameHas2Dots(pathname: *const core::ffi::c_char) -> core::ffi::c_i if needle.is_null() { return 0; } - if (needle == pathname || *needle.offset(-1_isize) as core::ffi::c_int == PATH_SEP) - && (*needle.offset(2) as core::ffi::c_int == '\0' as i32 - || *needle.offset(2) as core::ffi::c_int == PATH_SEP) + if (needle == pathname || *needle.sub(1) as core::ffi::c_int == PATH_SEP) + && (*needle.add(2) as core::ffi::c_int == '\0' as i32 + || *needle.add(2) as core::ffi::c_int == PATH_SEP) { return 1; } - needle = needle.offset(1); + needle = needle.add(1); } } unsafe fn isFileNameValidForMirroredOutput(filename: *const core::ffi::c_char) -> core::ffi::c_int { @@ -1776,16 +1776,16 @@ unsafe fn convertPathnameToDirName(pathname: *mut core::ffi::c_char) { } let pos = strrchr(pathname, PATH_SEP); if pos.is_null() { - *pathname.offset(0) = '.' as i32 as core::ffi::c_char; - *pathname.offset(1) = '\0' as i32 as core::ffi::c_char; + *pathname = '.' as i32 as core::ffi::c_char; + *pathname.add(1) = '\0' as i32 as core::ffi::c_char; } else { *pos = '\0' as i32 as core::ffi::c_char; } } unsafe fn trimLeadingRootChar(pathname: *const core::ffi::c_char) -> *const core::ffi::c_char { assert!(!pathname.is_null()); - if *pathname.offset(0) as core::ffi::c_int == PATH_SEP { - return pathname.offset(1); + if *pathname as core::ffi::c_int == PATH_SEP { + return pathname.add(1); } pathname } @@ -1793,10 +1793,10 @@ unsafe fn trimLeadingCurrentDirConst( pathname: *const core::ffi::c_char, ) -> *const core::ffi::c_char { assert!(!pathname.is_null()); - if *pathname.offset(0) as core::ffi::c_int == '.' as i32 - && *pathname.offset(1) as core::ffi::c_int == PATH_SEP + if *pathname as core::ffi::c_int == '.' as i32 + && *pathname.add(1) as core::ffi::c_int == PATH_SEP { - return pathname.offset(2); + return pathname.add(2); } pathname } @@ -1838,9 +1838,9 @@ unsafe fn mallocAndJoin2Dir( ); *outDirBuffer.add(dir1Size) = 0; let mut buffer = outDirBuffer.add(dir1Size); - if dir1Size > 0 && *buffer.offset(-(1)) as core::ffi::c_int != PATH_SEP { + if dir1Size > 0 && *buffer.sub(1) as core::ffi::c_int != PATH_SEP { *buffer = PATH_SEP as core::ffi::c_char; - buffer = buffer.offset(1); + buffer = buffer.add(1); } memcpy( buffer as *mut core::ffi::c_void, @@ -1892,7 +1892,7 @@ unsafe fn mirrorSrcDirRecursive( } *sp = PATH_SEP as core::ffi::c_char; } - pp = sp.offset(1); + pp = sp.add(1); } mirrorSrcDir(srcDirName, outDirName) } @@ -1963,7 +1963,7 @@ unsafe fn makeUniqueMirroredDestDirs( ); let mut uniqueDirNr: c_uint = 1; let fresh5 = &mut (*uniqueDirNames.offset(uniqueDirNr.wrapping_sub(1) as isize)); - *fresh5 = *srcDirNames.offset(0); + *fresh5 = *srcDirNames; let mut i = 0; while i < nbFile { let prevDirName = *srcDirNames.offset(i.wrapping_sub(1) as isize); @@ -2194,7 +2194,7 @@ pub unsafe fn UTIL_countCores(logical: bool) -> core::ffi::c_int { break 'failed; } - siblings = atoi(sep.offset(1)); + siblings = atoi(sep.add(1)); } if strncmp(buff.as_mut_ptr(), c"cpu cores".as_ptr(), 9) == 0 { let sep = strchr(buff.as_mut_ptr(), b':' as core::ffi::c_int); @@ -2203,7 +2203,7 @@ pub unsafe fn UTIL_countCores(logical: bool) -> core::ffi::c_int { break 'failed; } - cpu_cores = atoi(sep.offset(1)); + cpu_cores = atoi(sep.add(1)); } } else if ferror(cpuinfo) != 0 { // fall back on the sysconf value diff --git a/programs/zstdcli.rs b/programs/zstdcli.rs index ae806f57..dbeb2004 100644 --- a/programs/zstdcli.rs +++ b/programs/zstdcli.rs @@ -715,10 +715,10 @@ unsafe fn waitEnter() { unsafe fn lastNameFromPath(path: *const core::ffi::c_char) -> *const core::ffi::c_char { let mut name = path; if !(strrchr(name, '/' as i32)).is_null() { - name = (strrchr(name, '/' as i32)).offset(1); + name = (strrchr(name, '/' as i32)).add(1); } if !(strrchr(name, '\\' as i32)).is_null() { - name = (strrchr(name, '\\' as i32)).offset(1); + name = (strrchr(name, '\\' as i32)).add(1); } name } @@ -751,7 +751,7 @@ unsafe fn readU32FromCharChecked( if result < last { return 1; } - *stringPtr = (*stringPtr).offset(1); + *stringPtr = (*stringPtr).add(1); } if **stringPtr as core::ffi::c_int == 'K' as i32 || **stringPtr as core::ffi::c_int == 'M' as i32 @@ -767,12 +767,12 @@ unsafe fn readU32FromCharChecked( } result <<= 10; } - *stringPtr = (*stringPtr).offset(1); + *stringPtr = (*stringPtr).add(1); if **stringPtr as core::ffi::c_int == 'i' as i32 { - *stringPtr = (*stringPtr).offset(1); + *stringPtr = (*stringPtr).add(1); } if **stringPtr as core::ffi::c_int == 'B' as i32 { - *stringPtr = (*stringPtr).offset(1); + *stringPtr = (*stringPtr).add(1); } } *value = result; @@ -789,7 +789,7 @@ unsafe fn readIntFromChar(stringPtr: *mut *const core::ffi::c_char) -> core::ffi let mut sign = 1; let mut result: core::ffi::c_uint = 0; if **stringPtr as core::ffi::c_int == '-' as i32 { - *stringPtr = (*stringPtr).offset(1); + *stringPtr = (*stringPtr).add(1); sign = -(1); } if readU32FromCharChecked(stringPtr, &raw mut result) != 0 { @@ -815,7 +815,7 @@ unsafe fn readSizeTFromCharChecked( if result < last { return 1; } - *stringPtr = (*stringPtr).offset(1); + *stringPtr = (*stringPtr).add(1); } if **stringPtr as core::ffi::c_int == 'K' as i32 || **stringPtr as core::ffi::c_int == 'M' as i32 @@ -831,12 +831,12 @@ unsafe fn readSizeTFromCharChecked( } result <<= 10; } - *stringPtr = (*stringPtr).offset(1); + *stringPtr = (*stringPtr).add(1); if **stringPtr as core::ffi::c_int == 'i' as i32 { - *stringPtr = (*stringPtr).offset(1); + *stringPtr = (*stringPtr).add(1); } if **stringPtr as core::ffi::c_int == 'B' as i32 { - *stringPtr = (*stringPtr).offset(1); + *stringPtr = (*stringPtr).add(1); } } *value = result; @@ -873,30 +873,30 @@ unsafe fn parseCoverParameters( ) != 0 { (*params).k = readU32FromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"d=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { (*params).d = readU32FromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"steps=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { (*params).steps = readU32FromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"split=\0" as *const u8 as *const core::ffi::c_char, @@ -904,10 +904,10 @@ unsafe fn parseCoverParameters( { let splitPercentage = readU32FromChar(&raw mut stringPtr); (*params).splitPoint = splitPercentage as core::ffi::c_double / 100.0f64; - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"shrink\0" as *const u8 as *const core::ffi::c_char, @@ -915,19 +915,19 @@ unsafe fn parseCoverParameters( { (*params).shrinkDictMaxRegression = kDefaultRegression; (*params).shrinkDict = 1; - if *stringPtr.offset(0) as core::ffi::c_int == '=' as i32 { - stringPtr = stringPtr.offset(1); + if *stringPtr as core::ffi::c_int == '=' as i32 { + stringPtr = stringPtr.add(1); (*params).shrinkDictMaxRegression = readU32FromChar(&raw mut stringPtr); } - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else { return 0; } } - if *stringPtr.offset(0) as core::ffi::c_int != 0 { + if *stringPtr as core::ffi::c_int != 0 { return 0; } if g_displayLevel >= 4 { @@ -956,50 +956,50 @@ unsafe fn parseFastCoverParameters( ) != 0 { (*params).k = readU32FromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"d=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { (*params).d = readU32FromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"f=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { (*params).f = readU32FromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"steps=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { (*params).steps = readU32FromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"accel=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { (*params).accel = readU32FromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"split=\0" as *const u8 as *const core::ffi::c_char, @@ -1007,10 +1007,10 @@ unsafe fn parseFastCoverParameters( { let splitPercentage = readU32FromChar(&raw mut stringPtr); (*params).splitPoint = splitPercentage as core::ffi::c_double / 100.0f64; - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"shrink\0" as *const u8 as *const core::ffi::c_char, @@ -1018,19 +1018,19 @@ unsafe fn parseFastCoverParameters( { (*params).shrinkDictMaxRegression = kDefaultRegression; (*params).shrinkDict = 1; - if *stringPtr.offset(0) as core::ffi::c_int == '=' as i32 { - stringPtr = stringPtr.offset(1); + if *stringPtr as core::ffi::c_int == '=' as i32 { + stringPtr = stringPtr.add(1); (*params).shrinkDictMaxRegression = readU32FromChar(&raw mut stringPtr); } - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else { return 0; } } - if *stringPtr.offset(0) as core::ffi::c_int != 0 { + if *stringPtr as core::ffi::c_int != 0 { return 0; } if g_displayLevel >= 4 { @@ -1065,7 +1065,7 @@ unsafe fn parseLegacyParameters( return 0; } *selectivity = readU32FromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != 0 { + if *stringPtr as core::ffi::c_int != 0 { return 0; } if g_displayLevel >= 4 { @@ -1114,20 +1114,20 @@ unsafe fn parseAdaptParameters( ) != 0 { *adaptMinPtr = readIntFromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"max=\0" as *const u8 as *const core::ffi::c_char, ) != 0 { *adaptMaxPtr = readIntFromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else { if g_displayLevel >= 4 { fprintf( @@ -1138,7 +1138,7 @@ unsafe fn parseAdaptParameters( return 0; } } - if *stringPtr.offset(0) as core::ffi::c_int != 0 { + if *stringPtr as core::ffi::c_int != 0 { return 0; } if *adaptMinPtr > *adaptMaxPtr { @@ -1167,10 +1167,10 @@ unsafe fn parseCompressionParameters( ) != 0 { (*params).windowLog = readU32FromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"chainLog=\0" as *const u8 as *const core::ffi::c_char, @@ -1181,10 +1181,10 @@ unsafe fn parseCompressionParameters( ) != 0 { (*params).chainLog = readU32FromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"hashLog=\0" as *const u8 as *const core::ffi::c_char, @@ -1195,10 +1195,10 @@ unsafe fn parseCompressionParameters( ) != 0 { (*params).hashLog = readU32FromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"searchLog=\0" as *const u8 as *const core::ffi::c_char, @@ -1209,10 +1209,10 @@ unsafe fn parseCompressionParameters( ) != 0 { (*params).searchLog = readU32FromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"minMatch=\0" as *const u8 as *const core::ffi::c_char, @@ -1223,10 +1223,10 @@ unsafe fn parseCompressionParameters( ) != 0 { (*params).minMatch = readU32FromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"targetLength=\0" as *const u8 as *const core::ffi::c_char, @@ -1237,10 +1237,10 @@ unsafe fn parseCompressionParameters( ) != 0 { (*params).targetLength = readU32FromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"strategy=\0" as *const u8 as *const core::ffi::c_char, @@ -1251,10 +1251,10 @@ unsafe fn parseCompressionParameters( ) != 0 { (*params).strategy = readU32FromChar(&raw mut stringPtr) as ZSTD_strategy; - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"overlapLog=\0" as *const u8 as *const core::ffi::c_char, @@ -1265,10 +1265,10 @@ unsafe fn parseCompressionParameters( ) != 0 { g_overlapLog = readU32FromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"ldmHashLog=\0" as *const u8 as *const core::ffi::c_char, @@ -1279,10 +1279,10 @@ unsafe fn parseCompressionParameters( ) != 0 { g_ldmHashLog = readU32FromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"ldmMinMatch=\0" as *const u8 as *const core::ffi::c_char, @@ -1293,10 +1293,10 @@ unsafe fn parseCompressionParameters( ) != 0 { g_ldmMinMatch = readU32FromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"ldmBucketSizeLog=\0" as *const u8 as *const core::ffi::c_char, @@ -1307,10 +1307,10 @@ unsafe fn parseCompressionParameters( ) != 0 { g_ldmBucketSizeLog = readU32FromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else if longCommandWArg( &raw mut stringPtr, b"ldmHashRateLog=\0" as *const u8 as *const core::ffi::c_char, @@ -1321,10 +1321,10 @@ unsafe fn parseCompressionParameters( ) != 0 { g_ldmHashRateLog = readU32FromChar(&raw mut stringPtr); - if *stringPtr.offset(0) as core::ffi::c_int != ',' as i32 { + if *stringPtr as core::ffi::c_int != ',' as i32 { break; } - stringPtr = stringPtr.offset(1); + stringPtr = stringPtr.add(1); } else { if g_displayLevel >= 4 { fprintf( @@ -1335,7 +1335,7 @@ unsafe fn parseCompressionParameters( return 0; } } - if *stringPtr.offset(0) as core::ffi::c_int != 0 { + if *stringPtr as core::ffi::c_int != 0 { return 0; } 1 @@ -1620,9 +1620,9 @@ unsafe fn init_cLevel() -> core::ffi::c_int { let mut sign = 1; if *ptr as core::ffi::c_int == '-' as i32 { sign = -(1); - ptr = ptr.offset(1); + ptr = ptr.add(1); } else if *ptr as core::ffi::c_int == '+' as i32 { - ptr = ptr.offset(1); + ptr = ptr.add(1); } if *ptr as core::ffi::c_int >= '0' as i32 && *ptr as core::ffi::c_int <= '9' as i32 { let mut absLevel: core::ffi::c_uint = 0; @@ -1762,7 +1762,7 @@ unsafe fn main_0( let mut memLimit = 0; let mut filenames = UTIL_allocateFileNamesTable(argCount as size_t); let file_of_names = UTIL_allocateFileNamesTable(argCount as size_t); - let mut programName = *argv.offset(0); + let mut programName = *argv; let mut outFileName = core::ptr::null(); let mut outDirName = core::ptr::null(); let mut outMirroredDirName = core::ptr::null(); @@ -1949,8 +1949,8 @@ unsafe fn main_0( UTIL_refFilename(filenames, argument); } else if strcmp(argument, b"-\0" as *const u8 as *const core::ffi::c_char) == 0 { UTIL_refFilename(filenames, stdinmark.as_ptr()); - } else if *argument.offset(0) as core::ffi::c_int == '-' as i32 { - if *argument.offset(1) as core::ffi::c_int == '-' as i32 { + } else if *argument as core::ffi::c_int == '-' as i32 { + if *argument.add(1) as core::ffi::c_int == '-' as i32 { if strcmp(argument, b"--\0" as *const u8 as *const core::ffi::c_char) == 0 { nextArgumentsAreFiles = 1; } else if strcmp( @@ -2331,7 +2331,7 @@ unsafe fn main_0( ); } else { let fresh0 = argument; - argument = argument.offset(1); + argument = argument.add(1); if *fresh0 as core::ffi::c_int != '=' as i32 || parseCoverParameters(argument, &raw mut coverParams) == 0 { @@ -2358,7 +2358,7 @@ unsafe fn main_0( ); } else { let fresh1 = argument; - argument = argument.offset(1); + argument = argument.add(1); if *fresh1 as core::ffi::c_int != '=' as i32 || parseFastCoverParameters( argument, @@ -2382,7 +2382,7 @@ unsafe fn main_0( dict = legacy; if *argument as core::ffi::c_int != 0 { let fresh2 = argument; - argument = argument.offset(1); + argument = argument.add(1); if *fresh2 as core::ffi::c_int != '=' as i32 || parseLegacyParameters(argument, &raw mut dictSelect) == 0 { @@ -2556,7 +2556,7 @@ unsafe fn main_0( ldmFlag = 1; ultra = 1; let ldmWindowLog = if *argument as core::ffi::c_int == '=' as i32 { - argument = argument.offset(1); + argument = argument.add(1); readU32FromChar(&raw mut argument) } else if *argument as core::ffi::c_int != 0 { badUsage(programName, originalArgument); @@ -2575,7 +2575,7 @@ unsafe fn main_0( { if *argument as core::ffi::c_int == '=' as i32 { let maxFast = -ZSTD_minCLevel() as u32; - argument = argument.offset(1); + argument = argument.add(1); let mut fastLevel = readU32FromChar(&raw mut argument); if fastLevel > maxFast { fastLevel = maxFast; @@ -2610,15 +2610,15 @@ unsafe fn main_0( } } } else { - argument = argument.offset(1); - while *argument.offset(0) as core::ffi::c_int != 0 { + argument = argument.add(1); + while *argument as core::ffi::c_int != 0 { if *argument as core::ffi::c_int >= '0' as i32 && *argument as core::ffi::c_int <= '9' as i32 { cLevel = readU32FromChar(&raw mut argument) as core::ffi::c_int; dictCLevel = cLevel; } else { - match *argument.offset(0) as core::ffi::c_int { + match *argument as core::ffi::c_int { 86 => { printVersion(); operationResult = 0; @@ -2636,33 +2636,33 @@ unsafe fn main_0( } 122 => { operation = zom_compress; - argument = argument.offset(1); + argument = argument.add(1); } 100 => { benchParams.mode = BMK_decodeOnly; if operation as core::ffi::c_uint == zom_bench as core::ffi::c_int as core::ffi::c_uint { - argument = argument.offset(1); + argument = argument.add(1); } else { operation = zom_decompress; - argument = argument.offset(1); + argument = argument.add(1); } } 99 => { forceStdout = 1; outFileName = stdoutmark.as_ptr(); - argument = argument.offset(1); + argument = argument.add(1); } 111 => { - argument = argument.offset(1); + argument = argument.add(1); NEXT_FIELD!(outFileName); } 110 => { - argument = argument.offset(1); + argument = argument.add(1); } 68 => { - argument = argument.offset(1); + argument = argument.add(1); NEXT_FIELD!(dictFileName); } 102 => { @@ -2671,72 +2671,72 @@ unsafe fn main_0( forceStdout = 1; followLinks = 1; allowBlockDevices = 1; - argument = argument.offset(1); + argument = argument.add(1); } 118 => { g_displayLevel += 1; - argument = argument.offset(1); + argument = argument.add(1); } 113 => { g_displayLevel -= 1; - argument = argument.offset(1); + argument = argument.add(1); } 107 => { removeSrcFile = 0; - argument = argument.offset(1); + argument = argument.add(1); } 67 => { FIO_setChecksumFlag(prefs, 2); - argument = argument.offset(1); + argument = argument.add(1); } 116 => { operation = zom_test; - argument = argument.offset(1); + argument = argument.add(1); } 77 => { - argument = argument.offset(1); + argument = argument.add(1); memLimit = readU32FromChar(&raw mut argument); } 108 => { operation = zom_list; - argument = argument.offset(1); + argument = argument.add(1); } 114 => { recursive = 1; - argument = argument.offset(1); + argument = argument.add(1); } 98 => { operation = zom_bench; - argument = argument.offset(1); + argument = argument.add(1); } 101 => { - argument = argument.offset(1); + argument = argument.add(1); cLevelLast = readU32FromChar(&raw mut argument) as core::ffi::c_int; } 105 => { - argument = argument.offset(1); + argument = argument.add(1); bench_nbSeconds = readU32FromChar(&raw mut argument); } 66 => { - argument = argument.offset(1); + argument = argument.add(1); chunkSize = readU32FromChar(&raw mut argument) as size_t; } 83 => { - argument = argument.offset(1); + argument = argument.add(1); separateFiles = 1; } 84 => { - argument = argument.offset(1); + argument = argument.add(1); nbWorkers = readU32FromChar(&raw mut argument); setThreads_non1 = (nbWorkers != 1) as core::ffi::c_int; } 115 => { - argument = argument.offset(1); + argument = argument.add(1); dictSelect = readU32FromChar(&raw mut argument); } 112 => { - argument = argument.offset(1); + argument = argument.add(1); if *argument as core::ffi::c_int >= '0' as i32 && *argument as core::ffi::c_int <= '9' as i32 { @@ -2748,7 +2748,7 @@ unsafe fn main_0( } } 80 => { - argument = argument.offset(1); + argument = argument.add(1); compressibility = readU32FromChar(&raw mut argument) as core::ffi::c_double / 100.0; @@ -2756,7 +2756,7 @@ unsafe fn main_0( _ => { let mut shortArgument: [core::ffi::c_char; 3] = ['-' as i32 as core::ffi::c_char, 0, 0]; - *shortArgument.as_mut_ptr().offset(1) = *argument.offset(0); + *shortArgument.as_mut_ptr().add(1) = *argument; badUsage(programName, shortArgument.as_mut_ptr()); operationResult = 1; break 'end; @@ -3096,7 +3096,7 @@ unsafe fn main_0( } } if (*filenames).tableSize == 1 - && strcmp(*((*filenames).fileNames).offset(0), stdinmark.as_ptr()) == 0 + && strcmp(*((*filenames).fileNames), stdinmark.as_ptr()) == 0 && outFileName.is_null() { outFileName = stdoutmark.as_ptr(); @@ -3296,7 +3296,7 @@ unsafe fn main_0( fCtx, prefs, outFileName, - *((*filenames).fileNames).offset(0), + *((*filenames).fileNames), dictFileName, cLevel, compressionParams, @@ -3320,7 +3320,7 @@ unsafe fn main_0( fCtx, prefs, outFileName, - *((*filenames).fileNames).offset(0), + *((*filenames).fileNames), dictFileName, ); } else { From b38367780692042bf5f8b4ae75b8e2584bc5c713 Mon Sep 17 00:00:00 2001 From: Mattias Wallin Date: Sat, 6 Jun 2026 17:26:08 +0200 Subject: [PATCH 16/16] programs/main: Only allow specific clippy lints --- programs/main.rs | 17 +++-------------- 1 file changed, 3 insertions(+), 14 deletions(-) diff --git a/programs/main.rs b/programs/main.rs index ff706e21..4937ff61 100644 --- a/programs/main.rs +++ b/programs/main.rs @@ -3,20 +3,9 @@ #![allow(non_snake_case)] #![allow(non_upper_case_globals)] // FIXME I guess -#![allow(clippy::all)] -#![warn(clippy::borrow_as_ptr)] -#![warn(clippy::absurd_extreme_comparisons)] -#![warn(clippy::eq_op)] -#![warn(clippy::unnecessary_cast)] -#![warn(clippy::field_reassign_with_default)] -#![warn(clippy::manual_clamp)] -#![warn(clippy::manual_checked_ops)] -#![warn(clippy::double_parens)] -#![warn(clippy::redundant_field_names)] -#![warn(clippy::if_same_then_else)] -#![warn(clippy::wildcard_in_or_patterns)] -#![warn(clippy::collapsible_if)] -#![warn(clippy::assertions_on_constants)] +#![allow(clippy::missing_safety_doc)] +#![allow(clippy::too_many_arguments)] +#![allow(clippy::nonminimal_bool)] extern crate libc; pub mod benchfn;