1 /*
2 Copyright (C) 2015-2021, Dirk Krause
3 SPDX-License-Identifier: BSD-3-Clause
4 */
5
6 /*
7 WARNING: This file was generated by the dkct program (see
8 http://dktools.sourceforge.net/ for details).
9 Changes you make here will be lost if dkct is run again!
10 You should modify the original source and run dkct on it.
11 Original source: dk4mem.ctr
12 */
13
14 /** @file dk4mem.c The dk4mem module.
15 */
16
17
18 #include "dk4conf.h"
19
20 #if DK4_ON_WINDOWS && (DK4_WIN_AVOID_CRT || DK4_WIN_DENY_CRT)
21 #ifndef WINDOWS_H_INCLUDED
22 #include <windows.h>
23 #define WINDOWS_H_INCLUDED 1
24 #endif
25 #endif
26
27 #include <libdk4base/dk4types.h>
28
29 #if DK4_HAVE_STRING_H
30 #ifndef STRING_H_INCLUDED
31 #include <string.h>
32 #define STRING_H_INCLUDED 1
33 #endif
34 #endif
35 #if DK4_HAVE_STRINGS_H
36 #ifndef STRINGS_H_INCLUDED
37 #include <strings.h>
38 #define STRINGS_H_INCLUDED 1
39 #endif
40 #endif
41 #if DK4_HAVE_ASSERT_H
42 #ifndef ASSERT_H_INCLUDED
43 #include <assert.h>
44 #define ASSERT_H_INCLUDED 1
45 #endif
46 #endif
47
48 #include <libdk4base/dk4mem.h>
49 #include <libdk4base/dk4numco.h>
50
51
52
53
54
55
56 #if ((!(DK4_ON_WINDOWS)) && (!(DK4_HAVE_MEMSET)) && (!(DK4_HAVE_BZERO)))
57
58 static
59 void
dk4mem_fallback_i_reset(unsigned char * bptr,size_t sz)60 dk4mem_fallback_i_reset(unsigned char *bptr, size_t sz)
61 {
62 while (0 < sz--) { *(bptr++) = '\0'; }
63 }
64
65
66
67 void
68
dk4mem_fallback_reset(void * bptr,size_t sz)69 dk4mem_fallback_reset(void *bptr, size_t sz)
70 {
71 #if DK4_USE_ASSERT
72 assert(NULL != bptr);
73 assert(0 < sz);
74 #endif
75 dk4mem_fallback_i_reset((unsigned char *)bptr, sz);
76 }
77
78
79 #endif
80
81
82 void
83
dk4mem_reset(void * bptr,size_t sz,dk4_er_t * erp)84 dk4mem_reset(void *bptr, size_t sz, dk4_er_t *erp)
85 {
86
87 #if DK4_USE_ASSERT
88 assert(NULL != bptr);
89 assert(0 < sz);
90 #endif
91 if ((NULL != bptr) && (0 < sz)) {
92 DK4_MEMRES(bptr, sz);
93 } else {
94 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
95 }
96
97 }
98
99
100
101 void
102
dk4mem_set(void * bptr,size_t sz,unsigned char uc,dk4_er_t * erp)103 dk4mem_set(void *bptr, size_t sz, unsigned char uc, dk4_er_t *erp)
104 {
105 #if DK4_HAVE_MEMSET \
106 && (!(DK4_ON_WINDOWS && (DK4_WIN_AVOID_CRT || DK4_WIN_DENY_CRT)))
107 #if DK4_USE_ASSERT
108 assert(NULL != bptr);
109 assert(0 < sz);
110 #endif
111 if ((NULL != bptr) && (0 < sz)) {
112 memset(bptr, (int)uc, sz);
113 }
114 else {
115 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
116 }
117 #else
118 unsigned char *ucptr;
119 #if DK4_USE_ASSERT
120 assert(NULL != bptr);
121 assert(0 < sz);
122 #endif
123 if ((NULL != bptr) && (0 < sz)) {
124 ucptr = (unsigned char *)bptr;
125 while (0 < sz--) { *(ucptr++) = uc; }
126 }
127 else {
128 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
129 }
130 #endif
131 }
132
133
134
135 #if ((!(DK4_ON_WINDOWS)) && (!(DK4_HAVE_MEMCPY)) && (!(DK4_HAVE_BCOPY)))
136
137 static
138 void
dk4mem_fallback_i_cpy(unsigned char * dst,const unsigned char * src,size_t sz)139 dk4mem_fallback_i_cpy(unsigned char *dst, const unsigned char *src, size_t sz)
140 {
141 while(0 < sz--) { *(dst++) = *(src++); }
142 }
143
144
145
146 void
147
dk4mem_fallback_cpy(void * dst,const void * src,size_t sz)148 dk4mem_fallback_cpy(void *dst, const void *src, size_t sz)
149 {
150 #if DK4_USE_ASSERT
151 assert(NULL != dst);
152 assert(NULL != src);
153 assert(0 < sz);
154 #endif
155 dk4mem_fallback_i_cpy(
156 (unsigned char *)dst,
157 (const unsigned char *)src,
158 sz
159 );
160 }
161
162
163 #endif
164
165
166 void
167
dk4mem_cpy(void * dst,void const * src,size_t sz,dk4_er_t * erp)168 dk4mem_cpy(void *dst, void const *src, size_t sz, dk4_er_t *erp)
169 {
170 #if DK4_USE_ASSERT
171 assert(NULL != dst);
172 assert(NULL != src);
173 assert(0 < sz);
174 #endif
175 if ((NULL != dst) && (NULL != src) && (0 < sz)) {
176 DK4_MEMCPY(dst, src, sz);
177 } else {
178 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
179 }
180 }
181
182
183
184 #if (DK4_ON_WINDOWS && (DK4_WIN_AVOID_CRT || DK4_WIN_DENY_CRT)) \
185 || ((!(DK4_ON_WINDOWS)) && (!(DK4_HAVE_MEMCMP)) && (!(DK4_HAVE_BCMP)))
186
187 static
188 int
dk4mem_fallback_i_cmp(const unsigned char * s1,const unsigned char * s2,size_t sz)189 dk4mem_fallback_i_cmp(
190 const unsigned char *s1,
191 const unsigned char *s2,
192 size_t sz
193 )
194 {
195 int back = 0;
196 while ((0 < sz--) && (0 == back)) {
197 if (*s1 > *s2) {
198 back = 1;
199 } else {
200 if (*s1 < *s2) {
201 back = -1;
202 }
203 }
204 s1++; s2++;
205 }
206 return back;
207 }
208
209
210
211 int
212
dk4mem_fallback_cmp(const void * s1,const void * s2,size_t sz)213 dk4mem_fallback_cmp(const void *s1, const void *s2, size_t sz)
214 {
215 #if DK4_USE_ASSERT
216 assert(NULL != s1);
217 assert(NULL != s2);
218 assert(0 < sz);
219 #endif
220 return(
221 dk4mem_fallback_i_cmp(
222 (const unsigned char *)s1,
223 (const unsigned char *)s2,
224 sz
225 )
226 );
227 }
228
229 #endif
230
231
232 int
233
dk4mem_cmp(const void * s1,const void * s2,size_t sz,dk4_er_t * erp)234 dk4mem_cmp(const void *s1, const void *s2, size_t sz, dk4_er_t *erp)
235 {
236 int back = 0;
237 #if DK4_USE_ASSERT
238 assert(NULL != s1);
239 assert(NULL != s2);
240 assert(0 < sz);
241 #endif
242 if ((NULL != s1) && (NULL != s2) && (0 < sz)) {
243 back = DK4_MEMCMP(s1, s2, sz);
244 } else {
245 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
246 }
247 return back;
248 }
249
250
251
252
253 #if (DK4_ON_WINDOWS) || (DK4_HAVE_MALLOC && DK4_HAVE_FREE)
254
255 void *
256
dk4mem_malloc_bytes(size_t bytes,dk4_er_t * erp)257 dk4mem_malloc_bytes(size_t bytes, dk4_er_t *erp)
258 {
259 void *back = NULL; /* Function result. */
260 #if DK4_USE_ASSERT
261 assert(0 < bytes);
262 #endif
263 if (0 < bytes) {
264 #if DK4_ON_WINDOWS
265 /* +++ Windows */
266 #if DK4_WIN_AVOID_CRT || DK4_WIN_DENY_CRT
267 if ((dk4_um_t)bytes <= (dk4_um_t)0xFFFFFFFFUL) {
268 #if DK4_USE_WINDOWS_LOCAL_ALLOC
269 back = (void*)LocalAlloc(LMEM_FIXED, (DWORD)bytes);
270 #else
271 back = (void*)GlobalAlloc(GMEM_FIXED, (DWORD)bytes);
272 #endif
273 if (NULL == back) {
274 dk4error_set_elsize_nelem(erp,DK4_E_MEMORY_ALLOCATION_FAILED,1,bytes);
275 }
276 } else {
277 dk4error_set_simple_error_code(erp, DK4_E_MATH_OVERFLOW);
278 }
279 #else
280 back = malloc(bytes);
281 if (NULL == back) {
282 dk4error_set_elsize_nelem(erp, DK4_E_MEMORY_ALLOCATION_FAILED, 1, bytes);
283 }
284 #endif
285 /* --- Windows */
286 #else
287 /* +++ non-Windows */
288 back = malloc(bytes);
289 if (NULL == back) {
290 dk4error_set_elsize_nelem(erp, DK4_E_MEMORY_ALLOCATION_FAILED, 1, bytes);
291 }
292 /* --- non-Windows */
293 #endif
294 } else {
295 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
296 }
297 return back;
298 }
299
300
301
302 void *
303
dk4mem_malloc(size_t elsize,size_t nelem,dk4_er_t * erp)304 dk4mem_malloc(size_t elsize, size_t nelem, dk4_er_t *erp)
305 {
306 void *back = NULL;
307 size_t bytes;
308 #if DK4_USE_ASSERT
309 assert(0 < elsize);
310 assert(0 < nelem);
311 assert((SIZE_MAX / elsize) >= nelem);
312 #endif
313 if ((0 < elsize) && (0 < nelem)) {
314 if ((SIZE_MAX / elsize) >= nelem) {
315 bytes = elsize * nelem;
316 back = dk4mem_malloc_bytes(bytes, erp);
317 } else {
318 dk4error_set_simple_error_code(erp, DK4_E_MATH_OVERFLOW);
319 }
320 } else {
321 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
322 }
323 return back;
324 }
325
326
327
328 void *
329
dk4mem_calloc(size_t elsize,size_t nelem,dk4_er_t * erp)330 dk4mem_calloc(size_t elsize, size_t nelem, dk4_er_t *erp)
331 {
332 void *back = NULL;
333 #if DK4_USE_ASSERT
334 assert(0 < elsize);
335 assert(0 < nelem);
336 assert((SIZE_MAX / elsize) >= nelem);
337 #endif
338 if ((0 < elsize) && (0 < nelem)) {
339 if ((SIZE_MAX / elsize) >= nelem) {
340 #if DK4_ON_WINDOWS
341 /* +++ Windows */
342 #if DK4_WIN_AVOID_CRT || DK4_WIN_DENY_CRT
343 size_t bytes;
344 bytes = elsize * nelem;
345 if ((dk4_um_t)bytes <= (dk4_um_t)0xFFFFFFFFUL) {
346 #if DK4_USE_WINDOWS_LOCAL_ALLOC
347 back = (void *)LocalAlloc((LMEM_FIXED | LMEM_ZEROINIT), (DWORD)bytes);
348 #else
349 back = (void *)GlobalAlloc((GMEM_FIXED | GMEM_ZEROINIT), (DWORD)bytes);
350 #endif
351 if (NULL == back) {
352 dk4error_set_elsize_nelem(
353 erp, DK4_E_MEMORY_ALLOCATION_FAILED, elsize, nelem
354 );
355 }
356
357 } else {
358 dk4error_set_simple_error_code(erp, DK4_E_MATH_OVERFLOW);
359 }
360 #else
361 back = calloc(nelem, elsize);
362 if (NULL == back) {
363 dk4error_set_elsize_nelem(
364 erp, DK4_E_MEMORY_ALLOCATION_FAILED, elsize, nelem
365 );
366 }
367 #endif
368 /* --- Windows */
369 #else
370 /* +++ non-Windows */
371 #if DK4_HAVE_CALLOC
372 back = calloc(nelem, elsize);
373 if (NULL == back) {
374 dk4error_set_elsize_nelem(
375 erp, DK4_E_MEMORY_ALLOCATION_FAILED, elsize, nelem
376 );
377 }
378 #else
379 size_t bytes;
380 bytes = elsize * nelem;
381 back = malloc(bytes);
382 if (NULL != back) {
383 dk4mem_reset(back, bytes);
384 } else {
385 dk4error_set_elsize_nelem(
386 erp, DK4_E_MEMORY_ALLOCATION_FAILED, elsize, nelem
387 );
388 }
389 #endif
390 /* --- non-Windows */
391 #endif
392 } else {
393 dk4error_set_simple_error_code(erp, DK4_E_MATH_OVERFLOW);
394 }
395 } else {
396 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
397 }
398 return back;
399 }
400
401
402
403 void
404
dk4mem_free(void * ptr)405 dk4mem_free(void *ptr)
406 {
407 #if DK4_USE_ASSERT
408 assert(NULL != ptr);
409 #endif
410 if (NULL != ptr) {
411 #if DK4_ON_WINDOWS
412 /* +++ Windows */
413 #if DK4_WIN_AVOID_CRT || DK4_WIN_DENY_CRT
414 #if DK4_USE_WINDOWS_LOCAL_ALLOC
415 LocalFree((HLOCAL)ptr);
416 #else
417 GlobalFree((HLOCAL)ptr);
418 #endif
419 #else
420 free(ptr);
421 #endif
422 /* --- Windows */
423 #else
424 /* +++ non-Windows */
425 free(ptr);
426 /* --- non-Windows */
427 #endif
428 }
429 }
430
431 #endif
432 /* if defined(_WIN32) ... */
433
434