47 lines
2.5 KiB
C
47 lines
2.5 KiB
C
|
|
#ifndef RR_MEMORY_H
|
|
#define RR_MEMORY_H
|
|
|
|
#include <librr/types.h>
|
|
|
|
/// @brief Tests if two memory regions overlap partially or completely.
|
|
/// @param block1 Block to check for overlapping with block2.
|
|
// If the address of this block is higher than that of block2, the blocks will be swapped internally.
|
|
/// @param length1 The length of the first block.
|
|
/// @param block2 The second block to check for overlapping.
|
|
/// @param length2 The length of the second block.
|
|
/// @return Whether the two blocks overlap.
|
|
bool_t rr_mem_overlap(const void *block1, usz_t length1, const void *block2, usz_t length2);
|
|
|
|
/// @brief Checks if two memory blocks contain the equal data.
|
|
/// @param block1 Address of the data to be checked for equality with 'block2'
|
|
/// @param block2 Address of the other memory block. In cases where there is a clear correct version,
|
|
/// this should be the correct data to be checked against.
|
|
/// @param count How many bytes will be checked.
|
|
/// @return Whether the two memory regions are equal.
|
|
bool_t rr_memequ(const void *block1, const void *block2, usz_t count);
|
|
|
|
/// @brief Sets all bytes in a memory region all to one byte.
|
|
/// @param destination Address to the memory region to fill with one byte.
|
|
/// @param count Number of bytes to set; length of 'destination'
|
|
/// @param value Value to write to every bte of 'destination'.
|
|
void rr_memset(void *destination, usz_t count, u8_t value);
|
|
|
|
/// @brief Repeats a sequence until a number of bytes was filled, potentially only writing a sequence half-way.
|
|
/// @attention The sequence cannot be contained in the destination.
|
|
/// @param destination Address in memory in which the sequence will be repeated.
|
|
/// @param num_bytes How many bytes of the destination should be filled. The last sequence can be partially finished.
|
|
/// @param sequence Sequence of bytes which will be written to destination.
|
|
/// @param len_sequence Length of 'sequence'.
|
|
/// @return The number of attempted or partial repetitions which have been performed.
|
|
usz_t rr_memrep(void *destination, usz_t num_bytes, const void *sequence, usz_t len_sequence);
|
|
|
|
/// @brief Copies a given number of bytes from a source memory region to a destination memory region.
|
|
/// @attention The source and the destination cannot overlap!
|
|
/// @param destination Memory region to which to write.
|
|
/// @param source Memory region from which to read the bytes to write into the destination.
|
|
/// @param num_bytes Number of bytes to copy from the source to the destination.
|
|
void rr_memcopy(void *destination, const void *source, usz_t num_bytes);
|
|
|
|
#endif // RR_MEMORY_H
|