Mercurial > molko

comparison libmlk-core/core/alloc.c @ 252:95c2c4a72410

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
core: add alloc_set to set SDL allocators as well
author David Demelier <markand@malikania.fr>
date Tue, 01 Dec 2020 21:53:23 +0100
parents 71b3b7036de7
children 9b758eb84556
comparison
equal deleted inserted replaced
251:a6a850e65d23 252:95c2c4a72410
19 #include <assert.h> 19 #include <assert.h>
20 #include <errno.h> 20 #include <errno.h>
21 #include <stdlib.h> 21 #include <stdlib.h>
22 #include <string.h> 22 #include <string.h>
23 23
24 #include <SDL.h>
25
24 #include "alloc.h" 26 #include "alloc.h"
25 #include "error.h" 27 #include "error.h"
26 #include "panic.h" 28 #include "panic.h"
27 29
28 static void * 30 static void *
45 panicf("%s", strerror(errno)); 47 panicf("%s", strerror(errno));
46 48
47 return mem; 49 return mem;
48 } 50 }
49 51
50 struct allocator allocator = { 52 static const struct alloc_funcs default_alloc_funcs = {
51 .alloc = panic_alloc, 53 .alloc = panic_alloc,
52 .realloc = panic_realloc, 54 .realloc = panic_realloc,
53 .free = free 55 .free = free
54 }; 56 };
55 57
58 static const struct alloc_funcs *funcs = &default_alloc_funcs;
59
60 void
61 alloc_set(const struct alloc_funcs *newfuncs)
62 {
63 assert(funcs);
64 assert(funcs->alloc);
65 assert(funcs->realloc);
66 assert(funcs->free);
67
68 funcs = newfuncs;
69
70 /* Change SDL allocators as well. */
71 SDL_SetMemoryFunctions(alloc_new, alloc_array0, alloc_renew, free);
72 }
73
56 void * 74 void *
57 alloc_new(size_t size) 75 alloc_new(size_t size)
58 { 76 {
59 assert(size != 0); 77 assert(size != 0);
60 78
61 return allocator.alloc(size); 79 return funcs->alloc(size);
62 } 80 }
63 81
64 void * 82 void *
65 alloc_new0(size_t size) 83 alloc_new0(size_t size)
66 { 84 {
67 assert(size != 0); 85 assert(size != 0);
68 86
69 void *ptr; 87 void *ptr;
70 88
71 if ((ptr = allocator.alloc(size))) 89 if ((ptr = funcs->alloc(size)))
72 memset(ptr, 0, size); 90 memset(ptr, 0, size);
73 91
74 return ptr; 92 return ptr;
75 } 93 }
76 94
83 size_t total = n * size; 101 size_t total = n * size;
84 102
85 if (total / n != size) 103 if (total / n != size)
86 return errorf("%s", strerror(ENOMEM)), NULL; 104 return errorf("%s", strerror(ENOMEM)), NULL;
87 105
88 return allocator.alloc(total); 106 return funcs->alloc(total);
89 } 107 }
90 108
91 void * 109 void *
92 alloc_array0(size_t n, size_t size) 110 alloc_array0(size_t n, size_t size)
93 { 111 {
98 size_t total = n * size; 116 size_t total = n * size;
99 117
100 if (total / n != size) 118 if (total / n != size)
101 return errorf("%s", strerror(ENOMEM)), NULL; 119 return errorf("%s", strerror(ENOMEM)), NULL;
102 120
103 if ((mem = allocator.alloc(total))) 121 if ((mem = funcs->alloc(total)))
104 memset(mem, 0, total); 122 memset(mem, 0, total);
105 123
106 return mem; 124 return mem;
107 } 125 }
108 126
109 void * 127 void *
110 alloc_renew(void *ptr, size_t amount) 128 alloc_renew(void *ptr, size_t amount)
111 { 129 {
112 return allocator.realloc(ptr, amount); 130 return funcs->realloc(ptr, amount);
113 } 131 }
114 132
115 void * 133 void *
116 alloc_rearray(void *ptr, size_t n, size_t size) 134 alloc_rearray(void *ptr, size_t n, size_t size)
117 { 135 {
118 size_t total = n * size; 136 size_t total = n * size;
119 137
120 if (total / n != size) 138 if (total / n != size)
121 return errorf("%s", strerror(ENOMEM)), NULL; 139 return errorf("%s", strerror(ENOMEM)), NULL;
122 140
123 return allocator.realloc(ptr, total); 141 return funcs->realloc(ptr, total);
124 } 142 }
125 143
126 void * 144 void *
127 alloc_dup(const void *ptr, size_t size) 145 alloc_dup(const void *ptr, size_t size)
128 { 146 {
129 assert(ptr); 147 assert(ptr);
130 assert(size != 0); 148 assert(size != 0);
131 149
132 void *mem; 150 void *mem;
133 151
134 if ((mem = allocator.alloc(size))) 152 if ((mem = funcs->alloc(size)))
135 memcpy(mem, ptr, size); 153 memcpy(mem, ptr, size);
136 154
137 return mem; 155 return mem;
138 } 156 }
139 157
143 assert(src); 161 assert(src);
144 162
145 char *ret; 163 char *ret;
146 size_t length = strlen(src) + 1; 164 size_t length = strlen(src) + 1;
147 165
148 if ((ret = allocator.alloc(length))) 166 if ((ret = funcs->alloc(length)))
149 memcpy(ret, src, length + 1); 167 memcpy(ret, src, length + 1);
150 168
151 return ret; 169 return ret;
152 } 170 }
153 171