diff --git a/lib/common/bitstream.rs b/lib/common/bitstream.rs index cb200ea7..989e1f4d 100644 --- a/lib/common/bitstream.rs +++ b/lib/common/bitstream.rs @@ -105,9 +105,9 @@ pub(crate) unsafe fn BIT_closeCStream(bitC: *mut BIT_CStream_t) -> size_t { /// * Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems. /// * You can then retrieve bitFields stored into the local register, **in reverse order**. /// * Local register is explicitly reloaded from memory by the [`reload`] method. -/// * A reload guarantee a minimum of ((8*sizeof(bitD->bitContainer))-7) bits when its result is BIT_DStream_unfinished. +/// * A reload guarantee a minimum of ((8*sizeof(bitD->bitContainer))-7) bits when its result is [`StreamStatus::Unfinished`]. /// * Otherwise, it can be less than that, so proceed accordingly. -/// * Checking if DStream has reached its end can be performed with BIT_endOfDStream(). +/// * Checking if `DStream` has reached its end can be performed with [`BIT_endOfDStream`]. #[derive(Debug, Copy, Clone)] #[repr(C)] pub(crate) struct BIT_DStream_t<'a> { diff --git a/lib/common/huf.rs b/lib/common/huf.rs index 9d5a9b0f..06372eba 100644 --- a/lib/common/huf.rs +++ b/lib/common/huf.rs @@ -7,7 +7,7 @@ pub(crate) const HUF_BLOCKSIZE_MAX: usize = 128 * 1024; pub(crate) const HUF_WORKSPACE_SIZE: usize = (8 << 10) + 512; -/// Max runtime value of tableLog (due to static allocation); can be modified up to HUF_TABLELOG_ABSOLUTEMAX. +/// Max runtime value of tableLog (due to static allocation); can be modified up to [`HUF_TABLELOG_ABSOLUTEMAX`]. pub(crate) const HUF_TABLELOG_MAX: usize = 12; /// Default tableLog value when none specified pub(crate) const HUF_TABLELOG_DEFAULT: u32 = 11; @@ -16,7 +16,7 @@ pub(crate) const HUF_SYMBOLVALUE_MAX: u32 = 255; pub(crate) const HUF_CTABLE_WORKSPACE_SIZE_U32: usize = (4 * (HUF_SYMBOLVALUE_MAX as usize + 1)) + 192; -/// Absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work +/// Absolute limit of [`HUF_MAX_TABLELOG`]. Beyond that value, code does not work const HUF_TABLELOG_ABSOLUTEMAX: usize = 12; const _: () = assert!( HUF_TABLELOG_MAX <= HUF_TABLELOG_ABSOLUTEMAX, @@ -39,7 +39,7 @@ pub(crate) const HUF_OPTIMAL_DEPTH_THRESHOLD: core::ffi::c_int = ZSTD_btultra as pub(crate) type HUF_repeat = core::ffi::c_uint; /// Cannot use the previous table pub(crate) const HUF_repeat_none: HUF_repeat = 0; -/// Can use the previous table but it must be checked. Note : The previous table must have been constructed by HUF_compress{1, 4}X_repeat +/// Can use the previous table but it must be checked. Note : The previous table must have been constructed by `HUF_compress{1, 4}X_repeat` pub(crate) const HUF_repeat_check: HUF_repeat = 1; /// Can use the previous table and it is assumed to be valid pub(crate) const HUF_repeat_valid: HUF_repeat = 2; diff --git a/lib/common/zstd_internal.rs b/lib/common/zstd_internal.rs index c58320d6..4eb18b53 100644 --- a/lib/common/zstd_internal.rs +++ b/lib/common/zstd_internal.rs @@ -85,11 +85,11 @@ pub(crate) enum Overlap { OverlapSrcBeforeDst, } -/// Custom version of ZSTD_memcpy(), can over read/write up to WILDCOPY_OVERLENGTH bytes (if length==0) +/// Custom version of [`ZSTD_memcpy`], can over read/write up to [`WILDCOPY_OVERLENGTH`] bytes (if length==0) /// /// The `ovtype` controls the overlap detection -/// - ZSTD_no_overlap: The source and destination are guaranteed to be at least WILDCOPY_VECLEN bytes apart. -/// - ZSTD_overlap_src_before_dst: The src and dst may overlap, but they MUST be at least 8 bytes apart. +/// - [`Overlap::NoOverlap`]: The source and destination are guaranteed to be at least [`WILDCOPY_VECLEN`] bytes apart. +/// - [`Overlap::OverlapSrcBeforeDst`]: The src and dst may overlap, but they MUST be at least 8 bytes apart. /// The src buffer must be before the dst buffer. #[inline(always)] pub(crate) unsafe fn ZSTD_wildcopy( diff --git a/lib/decompress/huf_decompress.rs b/lib/decompress/huf_decompress.rs index ce83edb6..01e290f0 100644 --- a/lib/decompress/huf_decompress.rs +++ b/lib/decompress/huf_decompress.rs @@ -1943,8 +1943,8 @@ enum Decoder { /// Tells which decoder is likely to decode faster, /// based on a set of pre-computed metrics. /// -/// @return : 0==HUF_decompress4X1, 1==HUF_decompress4X2 . -/// Assumption : 0 < dst_size <= 128 KB */ +/// @return : `0==HUF_decompress4X1`, `1==HUF_decompress4X2` . +/// Assumption : 0 < `dst_size` <= 128 KB */ fn HUF_selectDecoder(dst_size: usize, src_size: usize) -> Decoder { let D256 = (dst_size >> 8) as u32; diff --git a/lib/decompress/zstd_ddict.rs b/lib/decompress/zstd_ddict.rs index 2a206c20..e4a93bda 100644 --- a/lib/decompress/zstd_ddict.rs +++ b/lib/decompress/zstd_ddict.rs @@ -224,7 +224,7 @@ pub unsafe extern "C" fn ZSTD_createDDict_advanced( /// The `dict`'s content is copied inside the [`ZSTD_DDict`], so `dict` can be released after /// [`ZSTD_DDict`] creation. /// -/// The DDict can be freed using [`ZSTD_freeDDict`]. +/// The [`ZSTD_DDict`] can be freed using [`ZSTD_freeDDict`]. /// /// # Returns /// @@ -341,7 +341,7 @@ pub const extern "C" fn ZSTD_estimateDDictSize( /// /// # Returns /// -/// - the size of the DDict, including the size of the DDict's `dictBuffer` if present +/// - the size of the [`ZSTD_DDict`], including the size of the [`ZSTD_DDict`]'s `dictBuffer` if present /// - 0 if the `ddict` is NULL #[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_sizeof_DDict))] pub unsafe extern "C" fn ZSTD_sizeof_DDict(ddict: *const ZSTD_DDict) -> size_t { diff --git a/lib/decompress/zstd_decompress.rs b/lib/decompress/zstd_decompress.rs index 67a67336..a6d6fad5 100644 --- a/lib/decompress/zstd_decompress.rs +++ b/lib/decompress/zstd_decompress.rs @@ -728,7 +728,7 @@ fn ZSTD_initDCtx_internal(dctx: &mut MaybeUninit) { /// # Limitations /// /// - currently not compatible with internal dictionary creation, triggered by [`ZSTD_initDStream_usingDict`] -/// - static DCtx is incompatible with legacy support +/// - static `DCtx` is incompatible with legacy support /// /// # Returns /// @@ -2848,7 +2848,7 @@ pub unsafe extern "C" fn ZSTD_initDStream(zds: *mut ZSTD_DStream) -> size_t { /// This function is deprecated, and is equivalent to first using [`ZSTD_DCtx_reset`] to reset the /// decompression context and then using [`ZSTD_DCtx_refDDict`] to reference the dictionary. /// -/// Note: DDict will just be referenced, and must outlive decompression session +/// Note: `DDict` will just be referenced, and must outlive decompression session #[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_initDStream_usingDDict))] pub unsafe extern "C" fn ZSTD_initDStream_usingDDict( dctx: *mut ZSTD_DStream, @@ -2885,7 +2885,7 @@ pub unsafe extern "C" fn ZSTD_resetDStream(dctx: *mut ZSTD_DStream) -> size_t { /// active for decompression of future frames using same [`ZSTD_DCtx`] decompression context. /// /// If called with [`ZSTD_dParameter::ZSTD_d_refMultipleDDicts`] enabled, repeated calls of this -/// function will store the [`ZSTD_DDict`] references in a table, and the DDict used for +/// function will store the [`ZSTD_DDict`] references in a table, and the `DDict` used for /// decompression will be determined at decompression time, as per the dict ID in the frame. The /// memory for the table is allocated on the first call to [`ZSTD_DCtx_refDDict`], and can be freed /// with [`ZSTD_freeDCtx`]. @@ -2894,7 +2894,7 @@ pub unsafe extern "C" fn ZSTD_resetDStream(dctx: *mut ZSTD_DStream) -> size_t { /// dictionary will be managed, and referencing a dictionary effectively "discards" any previous /// one. /// -/// Referencing a NULL DDict means "return to no-dictionary mode". +/// Referencing a NULL `DDict` means "return to no-dictionary mode". /// /// # Returns /// @@ -2903,7 +2903,7 @@ pub unsafe extern "C" fn ZSTD_resetDStream(dctx: *mut ZSTD_DStream) -> size_t { /// /// # Safety /// -/// The DDict is just referenced, its lifetime must outlive its usage from [`ZSTD_DCtx`]. +/// The `DDict` is just referenced, its lifetime must outlive its usage from [`ZSTD_DCtx`]. #[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_DCtx_refDDict))] pub unsafe extern "C" fn ZSTD_DCtx_refDDict( dctx: *mut ZSTD_DCtx, @@ -3297,7 +3297,7 @@ pub extern "C" fn ZSTD_decodingBufferSize_min( /// Instead of providing the `windowSize` manually, you can also deduce it from a valid frame /// header using [`ZSTD_estimateDStreamSize_fromFrame`] /// -/// Note: if streaming is initialized with [`ZSTD_initDStream_usingDict`], an internal DDict +/// Note: if streaming is initialized with [`ZSTD_initDStream_usingDict`], an internal `DDict` /// will be created, whose additional size is not estimated here. In this case, get total size by /// adding [`crate::ZSTD_estimateDDictSize`]. #[cfg_attr(feature = "export-symbols", export_name = crate::prefix!(ZSTD_estimateDStreamSize))] diff --git a/lib/decompress/zstd_decompress_block.rs b/lib/decompress/zstd_decompress_block.rs index 89152be7..4c5e806a 100644 --- a/lib/decompress/zstd_decompress_block.rs +++ b/lib/decompress/zstd_decompress_block.rs @@ -1068,14 +1068,14 @@ unsafe fn ZSTD_overlapCopy8(op: &mut *mut u8, ip: &mut *const u8, offset: size_t debug_assert!(unsafe { (*op).offset_from(*ip) } >= 8); } -/// Specialized version of memcpy() that is allowed to READ up to WILDCOPY_OVERLENGTH past the input buffer -/// and write up to 16 bytes past oend_w (op >= oend_w is allowed). +/// Specialized version of `memcpy` that is allowed to READ up to [`WILDCOPY_OVERLENGTH`] past the input buffer +/// and write up to 16 bytes past `oend_w` (op >= `oend_w` is allowed). /// This function is only called in the uncommon case where the sequence is near the end of the block. It /// should be fast for a single long sequence, but can be slow for several short sequences. /// /// @param ovtype controls the overlap detection -/// - Overlap::NoOverlap: The source and destination are guaranteed to be at least WILDCOPY_VECLEN bytes apart. -/// - Overlap::OverlapSrcBeforeDst: The src and dst may overlap and may be any distance apart. +/// - [`Overlap::NoOverlap`]: The source and destination are guaranteed to be at least [`WILDCOPY_VECLEN`] bytes apart. +/// - [`Overlap::OverlapSrcBeforeDst`]: The src and dst may overlap and may be any distance apart. /// The src buffer must be before the dst buffer. unsafe fn ZSTD_safecopy( mut op: *mut u8, @@ -1131,7 +1131,7 @@ unsafe fn ZSTD_safecopy( } /// This version allows overlap with dst before src, or handles the non-overlap case with dst after src -/// Kept separate from more common ZSTD_safecopy case to avoid performance impact to the safecopy common case */ +/// Kept separate from more common [`ZSTD_safecopy`] case to avoid performance impact to the safecopy common case */ unsafe fn ZSTD_safecopyDstBeforeSrc(mut op: *mut u8, mut ip: *const u8, length: size_t) { let diff = op.offset_from(ip) as ptrdiff_t; let oend = op.add(length); @@ -1168,7 +1168,7 @@ unsafe fn ZSTD_safecopyDstBeforeSrc(mut op: *mut u8, mut ip: *const u8, length: /// and unlikely cases, we can speed up the common cases. /// /// NOTE: This function needs to be fast for a single long sequence, but doesn't need -/// to be optimized for many small sequences, since those fall into ZSTD_execSequence(). +/// to be optimized for many small sequences, since those fall into [`ZSTD_execSequence`]. #[inline(never)] unsafe fn ZSTD_execSequenceEnd( mut op: *mut u8, @@ -1558,8 +1558,8 @@ fn ZSTD_updateFseStateWithDInfo( DStatePtr.state = usize::from(nextState) + lowBits; } -/// We need to add at most (ZSTD_WINDOWLOG_MAX_32 - 1) bits to read the maximum -/// offset bits. But we can only read at most STREAM_ACCUMULATOR_MIN_32 +/// We need to add at most `(ZSTD_WINDOWLOG_MAX_32 - 1)` bits to read the maximum +/// offset bits. But we can only read at most [`STREAM_ACCUMULATOR_MIN_32`] /// bits before reloading. This value is the maximum number of bytes we read /// after reloading when we are decoding long offsets. const LONG_OFFSETS_MAX_EXTRA_BITS_32: i32 = diff --git a/lib/dictBuilder/zdict.rs b/lib/dictBuilder/zdict.rs index 70708dac..a02e3946 100644 --- a/lib/dictBuilder/zdict.rs +++ b/lib/dictBuilder/zdict.rs @@ -35,7 +35,7 @@ struct EStats_ress_t { dict: *mut ZSTD_CDict, /// working context zc: *mut ZSTD_CCtx, - /// must be ZSTD_BLOCKSIZE_MAX allocated + /// must be [`ZSTD_BLOCKSIZE_MAX`] allocated workPlace: Box<[MaybeUninit]>, } @@ -734,7 +734,7 @@ fn ZDICT_insertSortCount( } /// Rewrite `countLit` to contain a mostly flat but still compressible distribution of literals. -/// Necessary to avoid generating a non-compressible distribution that HUF_writeCTable() cannot encode. +/// Necessary to avoid generating a non-compressible distribution that [`HUF_writeCTable`] cannot encode. fn ZDICT_flatLit(countLit: &mut [core::ffi::c_uint; 256]) { countLit.fill(2); diff --git a/lib/legacy/zstd_v06.rs b/lib/legacy/zstd_v06.rs index 1201d2fd..f6ff208f 100644 --- a/lib/legacy/zstd_v06.rs +++ b/lib/legacy/zstd_v06.rs @@ -2340,11 +2340,11 @@ unsafe fn ZSTDv06_frameHeaderSize(src: *const core::ffi::c_void, srcSize: size_t ZSTDv06_frameHeaderSize_min.wrapping_add(*ZSTDv06_fcs_fieldSize.as_ptr().offset(fcsId as isize)) } -/// ZSTDv06_getFrameParams() : +/// [`ZSTDv06_getFrameParams`] : /// decode Frame Header, or provide expected `srcSize`. /// @return : 0, `fparamsPtr` is correctly filled, /// >0, `srcSize` is too small, result is expected `srcSize`, -/// or an error code, which can be tested using ZSTDv06_isError() +/// or an error code, which can be tested using [`ZSTDv06_isError`] pub(crate) unsafe fn ZSTDv06_getFrameParams( fparamsPtr: *mut ZSTDv06_frameParams, src: *const core::ffi::c_void, diff --git a/lib/zstd.rs b/lib/zstd.rs index 71c131ed..05975c57 100644 --- a/lib/zstd.rs +++ b/lib/zstd.rs @@ -158,7 +158,7 @@ pub type ZSTD_allocFunction = pub struct ZSTD_format_e(u32); impl ZSTD_format_e { - /// zstd frame format, specified in zstd_compression_format.md (default) + /// zstd frame format, specified in `zstd_compression_format.md` (default) pub const ZSTD_f_zstd1: Self = Self(Format::ZSTD_f_zstd1 as u32); /// Variant of zstd frame format, without initial 4-bytes magic number. @@ -359,8 +359,8 @@ impl ZSTD_dParameter { /// Experimental parameter: if enabled and [`ZSTD_DCtx`] is allocated on the heap, then /// additional memory will be allocated to store references to multiple [`ZSTD_DDict`]. That /// is, multiple calls of [`ZSTD_DCtx_refDDict`] using a given [`ZSTD_DCtx`], rather than - /// overwriting the previous DDict reference, will instead store all references. At - /// decompression time, the appropriate `dictID` is selected from the set of DDicts based on + /// overwriting the previous `DDict` reference, will instead store all references. At + /// decompression time, the appropriate `dictID` is selected from the set of `DDict`s based on /// the `dictID` in the frame. /// /// **Warning:** Enabling this parameter and calling [`ZSTD_DCtx_refDDict`] will trigger memory @@ -506,21 +506,21 @@ impl ZSTD_ResetDirective { /// /// Zstd currently supports the use of a [`ZSTD_CDict`] in three ways: /// -/// - The contents of the CDict can be copied into the working context. This +/// - The contents of the `CDict` can be copied into the working context. This /// means that the compression can search both the dictionary and input /// while operating on a single set of internal tables. This makes /// the compression faster per byte of input. However, the initial copy of -/// the CDict's tables incurs a fixed cost at the beginning of the +/// the `CDict`'s tables incurs a fixed cost at the beginning of the /// compression. For small compressions (< 8 KB), that copy can dominate /// the cost of the compression. /// -/// - The CDict's tables can be used in-place. In this model, compression is +/// - The `CDict`'s tables can be used in-place. In this model, compression is /// slower per input byte, because the compressor has to search two sets of /// tables. However, this model incurs no start-up cost (as long as the /// working context's tables can be reused). For small inputs, this can be -/// faster than copying the CDict's tables. +/// faster than copying the `CDict`'s tables. /// -/// - The CDict's tables are not used at all, and instead we use the working +/// - The `CDict`'s tables are not used at all, and instead we use the working /// context alone to reload the dictionary and use params based on the source /// size. See [`ZSTD_compress_insertDictionary`] and [`ZSTD_compress_usingDict`]. /// This method is effective when the dictionary sizes are very small relative diff --git a/programs/fileio.rs b/programs/fileio.rs index 06fb1adb..a6049eee 100644 --- a/programs/fileio.rs +++ b/programs/fileio.rs @@ -5231,7 +5231,7 @@ unsafe fn FIO_getLargestFileSize( maxFileSize } -/// FIO_compressMultipleFilenames() : +/// [`FIO_compressMultipleFilenames`] : /// compress nbFiles files /// into either one destination (outFileName), /// or into one file each (outFileName == NULL, but suffix != NULL),