1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
/*
* Copyright (c) 2023 Marc Pervaz Boocha
*
* SPDX-License-Identifier: MIT
*/
#ifndef CALT_MEM_H
#define CALT_MEM_H
#include <stddef.h>
inline void *calt_memset(void *restrict dest, unsigned char value, size_t count) {
unsigned char *p = dest;
while (count-- > 0) {
*p++ = value;
}
return dest;
}
inline void *calt_memset_null(void *dest, unsigned char value, size_t count) {
return dest ? calt_memset(dest, value, count) : NULL;
}
inline void *calt_memzero(void *dest, size_t count) {
return calt_memset(dest, '\0', count);
}
inline void *calt_memzero_null(void *dest, size_t count) {
return dest ? calt_memzero(dest, count) : NULL;
}
inline void *calt_memcpy(void *restrict dest, const void *restrict src,
size_t count) {
unsigned char *d = dest;
unsigned char const *s = src;
while (count-- > 0) {
*d++ = *s++;
}
return dest;
}
inline void *calt_memcpy_null(void *restrict dest, void const *restrict src,
size_t count) {
return dest ? calt_memcpy(dest, src, count) : NULL;
}
extern void *calt_memccpy(void *restrict dest, void const *restrict src,
unsigned char value, size_t count);
inline void *calt_memccpy_null(void *restrict dest, void const *restrict src,
unsigned char value, size_t count) {
return dest ? calt_memccpy(dest, src, value, count) : NULL;
}
inline void *calt_memmove(void *dest, void const *src, size_t count) {
unsigned char *d = dest;
unsigned char const *s = src;
if (d > s) {
d += count;
s += count;
while (count-- > 0) {
*--d = *--s;
}
} else if (d < s) {
calt_memcpy(dest, src, count);
}
return dest;
}
inline void *calt_memmove_null(void *dest, void const *src, size_t count) {
return dest ? calt_memmove(dest, src, count) : NULL;
}
inline void *calt_memchr(void const *ptr, unsigned char value, size_t count) {
unsigned char const *p = ptr;
while (count-- > 0) {
if (*p == value) {
return (void *)p;
}
p++;
}
return NULL;
}
inline void *calt_memrchr(void const *ptr, unsigned char value, size_t count) {
unsigned char const *p = ptr;
p = p + count;
while (count > 0) {
if (*(--p) == value) {
return (void *)p;
}
}
return NULL;
}
inline int calt_memcmp(const void *ptr1, const void *ptr2, size_t count) {
const unsigned char *p1 = ptr1;
const unsigned char *p2 = ptr2;
while (count-- > 0) {
if (*p1 != *p2) {
return (*p1 < *p2) ? -1 : 1;
}
p1++;
p2++;
}
return 0;
}
inline void calt_memswap(void *restrict ptr1, void *restrict ptr2, size_t size) {
unsigned char *p1 = ptr1;
unsigned char *p2 = ptr2;
while (size-- > 0) {
unsigned char temp = *p1;
*p1++ = *p2;
*p2++ = temp;
}
}
inline size_t calt_memlen(void const* ptr, unsigned char value, size_t size) {
unsigned char const *p = ptr;
size_t len = 0;
while (size-- > 0 && *p != value) {
p++;
len++;
}
return len;
}
extern size_t calt_memhash(void const *ptr, size_t count);
inline void *calt_memmem(void const *haystack, size_t haystacklen,
void const *needle, size_t needlelen) {
unsigned char const *p = haystack;
unsigned char const *end = p + haystacklen - needlelen;
while (p <= end) {
if (calt_memcmp(p, needle, needlelen) == 0) {
return (void *)p;
}
p++;
}
return NULL;
}
inline void calt_memrev(void *ptr, size_t size) {
unsigned char *p1 = ptr;
unsigned char *p2 = p1 + size - 1;
while (p1 < p2) {
unsigned char temp = *p1;
*p1++ = *p2;
*p2-- = temp;
}
}
#endif
|
