mem.h File Reference

#include <zrtos/types.h>
#include <zrtos/cast.h>

Include dependency graph for mem.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	zrtos_mem__swap (void *dest, void *src, size_t len)
void	zrtos_mem__swap_ex (void *ptr, size_t offest_dest, size_t offset_src, size_t len)
void	zrtos_mem__left_rotate (void *ptr, size_t length, size_t buffer_length)
void	zrtos_mem__move_right_overlapping (void *dest, void *src, size_t length)
void	zrtos_mem__move_left_overlapping (void *dest, void *src, size_t length)
void	zrtos_mem__cpy (void *dest, void *src, size_t length)
int	zrtos_mem__cmp (void *str1, void *str2, size_t count)
void	zrtos_mem__reverse (void *dest, size_t len)
void	zrtos_mem__set (void *dest, uint8_t value, size_t len)
void	zrtos_mem__zero (void *dest, size_t len)
void *	zrtos_mem__search (const void *key, const void *base, size_t high, size_t size, int(*compar)(const void *, const void *))
void	zrtos_mem__sort (void *base, size_t nel, size_t width, int(*comp)(const void *, const void *))
size_t	zrtos_mem__from_hex (void *dest, char *src, size_t len)

Function Documentation

zrtos_mem__cmp()

int zrtos_mem__cmp	(	void *	str1,
		void *	str2,
		size_t	count
	)

Definition at line 113 of file mem.h.

                                                        {
    uint8_t *s1 = ZRTOS_CAST(uint8_t*,str1);
    uint8_t *s2 = ZRTOS_CAST(uint8_t*,str2);

    while(count-- > 0){
        if(*s1++ != *s2++){
            return s1[-1] < s2[-1] ? -1 : 1;
        }
    }

    return 0;
}

Here is the caller graph for this function:

zrtos_mem__cpy()

void zrtos_mem__cpy	(	void *	dest,
		void *	src,
		size_t	length
	)

Definition at line 105 of file mem.h.

 {
    zrtos_mem__move_left_overlapping(dest,src,length);
}

Here is the call graph for this function:

Here is the caller graph for this function:

zrtos_mem__from_hex()

size_t zrtos_mem__from_hex	(	void *	dest,
		char *	src,
		size_t	len
	)

Definition at line 209 of file mem.h.

                                                           {
    uint8_t *tmp_dest = ZRTOS_CAST(uint8_t*,dest);
    while(len--){
        uint8_t h = (*src++) - '0';
        uint8_t l = (*src++) - '0';

        if(h > 9){
            h -= 'A' - '9';
        }
        if(l > 9){
            l -= 'A' - '9';
        }

        *tmp_dest++ = (h << 4) | l;
    }
    return zrtos_types__ptr_get_byte_distance(tmp_dest,dest);
}

Here is the call graph for this function:

zrtos_mem__left_rotate()

void zrtos_mem__left_rotate	(	void *	ptr,
		size_t	length,
		size_t	buffer_length
	)

Definition at line 50 of file mem.h.

 {
    size_t d = length;
    size_t n = buffer_length;
    size_t i = d;
    size_t j = n - d;
    while(i != j){
        if(i < j){
            //A is shorter
            zrtos_mem__swap_ex(ptr, d - i, d + j - i, i);
            j -= i;
        }else{
            //B is shorter
            zrtos_mem__swap_ex(ptr, d - i, d, j);
            i -= j;
        }
    }
    //Finally, block swap A and B
    zrtos_mem__swap_ex(ptr, d - i, d, i);
}

Here is the call graph for this function:

Here is the caller graph for this function:

zrtos_mem__move_left_overlapping()

void zrtos_mem__move_left_overlapping	(	void *	dest,
		void *	src,
		size_t	length
	)

Definition at line 92 of file mem.h.

 {
    uint8_t *tmp_dest = ZRTOS_CAST(uint8_t*,dest);
    uint8_t *tmp_src = ZRTOS_CAST(uint8_t*,src);
    while(length--){
        *tmp_dest++ = *tmp_src++;
    }
}

Here is the caller graph for this function:

zrtos_mem__move_right_overlapping()

void zrtos_mem__move_right_overlapping	(	void *	dest,
		void *	src,
		size_t	length
	)

Definition at line 78 of file mem.h.

 {
    uint8_t *tmp_dest = ZRTOS_CAST(uint8_t*,dest);
    uint8_t *tmp_src = ZRTOS_CAST(uint8_t*,src);
    tmp_dest += --length;
    tmp_src += length++;
    while(length--){
        *tmp_dest-- = *tmp_src--;
    }
}

Here is the caller graph for this function:

zrtos_mem__reverse()

void zrtos_mem__reverse	(	void *	dest,
		size_t	len
	)

Definition at line 126 of file mem.h.

                                              {
    uint8_t *tmp_dest = ZRTOS_CAST(uint8_t*,dest);
    uint8_t *tmp_src = tmp_dest + len;
    len>>=1;
    while(len--){
        --tmp_src;
        ZRTOS_TYPES__SWAP_PTR_CONTENTS(tmp_dest,tmp_src);
        tmp_dest++;
    }
}

Here is the caller graph for this function:

zrtos_mem__search()

void* zrtos_mem__search	(	const void *	key,
		const void *	base,
		size_t	high,
		size_t	size,
		int(*)(const void *, const void *)	compar
	)

Definition at line 148 of file mem.h.

{
    register char *p;
    size_t low;
    size_t mid;
    int r;

    if (size > 0) {             /* TODO: change this to an assert?? */
        low = 0;
        while (low < high) {
            mid = low + ((high - low) >> 1); /* Avoid possible overflow here. */
            p = ((char *)base) + mid * size; /* Could overflow here... */
            r = (*compar)(key, p); /* but that's an application problem! */
            if (r > 0) {
                low = mid + 1;
            } else if (r < 0) {
                high = mid;
            } else {
                return p;
            }
        }
    }
    return NULL;
}

Here is the caller graph for this function:

zrtos_mem__set()

void zrtos_mem__set	(	void *	dest,
		uint8_t	value,
		size_t	len
	)

Definition at line 137 of file mem.h.

                                                        {
    uint8_t *tmp_dest = ZRTOS_CAST(uint8_t*,dest);
    while(len--){
        *tmp_dest++ = value;
    }
}

Here is the caller graph for this function:

zrtos_mem__sort()

void zrtos_mem__sort	(	void *	base,
		size_t	nel,
		size_t	width,
		int(*)(const void *, const void *)	comp
	)

Definition at line 174 of file mem.h.

{
    size_t wnel, gap, wgap, i, j, k;
    char *a, *b, tmp;

    wnel = width * nel;
    for (gap = 0; ++gap < nel;){
        gap *= 3;
    }
    while ((gap /= 3) != 0) {
        wgap = width * gap;
        for (i = wgap; i < wnel; i += width) {
            for (j = i - wgap; ;j -= wgap) {
                a = j + (char *)base;
                b = a + wgap;
                if ((*comp)(a, b) <= 0){
                    break;
                }
                k = width;
                do {
                    tmp = *a;
                    *a++ = *b;
                    *b++ = tmp;
                } while (--k);
                if (j < wgap){
                    break;
                }
            }
        }
    }
}

zrtos_mem__swap()

void zrtos_mem__swap	(	void *	dest,
		void *	src,
		size_t	len
	)

Swap len bytes of dest and src inplace.

Parameters

[in]	dest	destination
[in]	src	source
[in]	len	byte length to swap

Returns

Nothing

Definition at line 27 of file mem.h.

                                                       {
    uint8_t *tmp_dest = ZRTOS_CAST(uint8_t*,dest);
    uint8_t *tmp_src = ZRTOS_CAST(uint8_t*,src);
    while(len--){
        ZRTOS_TYPES__SWAP_PTR_CONTENTS(tmp_src,tmp_dest);
        tmp_src++;
        tmp_dest++;
    }
}

Here is the caller graph for this function:

zrtos_mem__swap_ex()

void zrtos_mem__swap_ex	(	void *	ptr,
		size_t	offest_dest,
		size_t	offset_src,
		size_t	len
	)

Definition at line 37 of file mem.h.

 {
    zrtos_mem__swap(
         zrtos_types__ptr_add(ptr,offest_dest)
        ,zrtos_types__ptr_add(ptr,offset_src)
        ,len
    );
}

Here is the call graph for this function:

Here is the caller graph for this function:

zrtos_mem__zero()

void zrtos_mem__zero	(	void *	dest,
		size_t	len
	)

Definition at line 144 of file mem.h.

                                           {
    zrtos_mem__set(dest,0,len);
}

Here is the call graph for this function:

Here is the caller graph for this function: