Mercurial > hg > dmlib

comparison src/dmgrowbuf.c @ 2586:9807ae37ad69

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Require stdbool.h, we require C11 now.
author Matti Hamalainen <ccr@tnsp.org>
date Thu, 08 Dec 2022 15:59:22 +0200
parents c6ee41fd98dd
children
comparison
equal deleted inserted replaced
2585:ef6c826c5b7a 2586:9807ae37ad69
40 40
41 buf->len = 0; 41 buf->len = 0;
42 buf->offs = 0; 42 buf->offs = 0;
43 buf->size = initial; 43 buf->size = initial;
44 buf->mingrow = mingrow; 44 buf->mingrow = mingrow;
45 buf->backwards = FALSE; 45 buf->backwards = false;
46 buf->is_const = FALSE; 46 buf->is_const = false;
47 47
48 // Allocate the data 48 // Allocate the data
49 if ((buf->data = dmMalloc0(initial)) == NULL) 49 if ((buf->data = dmMalloc0(initial)) == NULL)
50 return DMERR_MALLOC; 50 return DMERR_MALLOC;
51 51
98 memcpy(dst->data, src->data, src->size); 98 memcpy(dst->data, src->data, src->size);
99 if (enlarge > 0) 99 if (enlarge > 0)
100 memset(dst->data + src->size, 0, enlarge); 100 memset(dst->data + src->size, 0, enlarge);
101 101
102 // And reset some struct information 102 // And reset some struct information
103 dst->is_const = FALSE; 103 dst->is_const = false;
104 104
105 return dst; 105 return dst;
106 } 106 }
107 107
108 108
114 DM_DBG("dmGrowBufConstCopy(dst=%p, src=%p):\n" 114 DM_DBG("dmGrowBufConstCopy(dst=%p, src=%p):\n"
115 " data=%p, size=%" DM_PRIu_SIZE_T ", len=%" DM_PRIu_SIZE_T ", offs=%" DM_PRIu_SIZE_T "\n", 115 " data=%p, size=%" DM_PRIu_SIZE_T ", len=%" DM_PRIu_SIZE_T ", offs=%" DM_PRIu_SIZE_T "\n",
116 dst, src, src->data, src->size, src->len, src->offs); 116 dst, src, src->data, src->size, src->len, src->offs);
117 117
118 memcpy(dst, src, sizeof(DMGrowBuf)); 118 memcpy(dst, src, sizeof(DMGrowBuf));
119 dst->is_const = TRUE; 119 dst->is_const = true;
120 120
121 return dst; 121 return dst;
122 } 122 }
123 123
124 124
130 DM_DBG("dmGrowBufConstCreateFrom(dst=%p, data=%p, len=%" DM_PRIu_SIZE_T ")\n", 130 DM_DBG("dmGrowBufConstCreateFrom(dst=%p, data=%p, len=%" DM_PRIu_SIZE_T ")\n",
131 dst, data, len); 131 dst, data, len);
132 132
133 dst->data = data; 133 dst->data = data;
134 dst->len = dst->size = len; 134 dst->len = dst->size = len;
135 dst->is_const = TRUE; 135 dst->is_const = true;
136 136
137 return dst; 137 return dst;
138 } 138 }
139 139
140 140
171 return dmGrowBufCopy(dst, 171 return dmGrowBufCopy(dst,
172 dmGrowBufConstCreateFrom(&tmp, src->data + offs, len), enlarge); 172 dmGrowBufConstCreateFrom(&tmp, src->data + offs, len), enlarge);
173 } 173 }
174 174
175 175
176 static BOOL dmGrowBufRealloc(DMGrowBuf *buf, const size_t nsize, const BOOL clear) 176 static bool dmGrowBufRealloc(DMGrowBuf *buf, const size_t nsize, const bool clear)
177 { 177 {
178 DM_DBG("dmGrowBufRealloc(%p):\n" 178 DM_DBG("dmGrowBufRealloc(%p):\n"
179 " size=%" DM_PRIu_SIZE_T ", nsize=%" DM_PRIu_SIZE_T 179 " size=%" DM_PRIu_SIZE_T ", nsize=%" DM_PRIu_SIZE_T
180 ", offs=%" DM_PRIu_SIZE_T "\n", 180 ", offs=%" DM_PRIu_SIZE_T "\n",
181 buf, buf->size, nsize, buf->offs); 181 buf, buf->size, nsize, buf->offs);
182 182
183 if (buf->is_const) 183 if (buf->is_const)
184 return FALSE; 184 return false;
185 185
186 // Can't be smaller than current size! 186 // Can't be smaller than current size!
187 if (nsize < buf->size) 187 if (nsize < buf->size)
188 return FALSE; 188 return false;
189 189
190 if ((buf->data = dmRealloc(buf->data, nsize)) == NULL) 190 if ((buf->data = dmRealloc(buf->data, nsize)) == NULL)
191 return FALSE; 191 return false;
192 192
193 // For buffers growing backwards, we must move the 193 // For buffers growing backwards, we must move the
194 // current data to the end of the buffer .. 194 // current data to the end of the buffer ..
195 size_t clrsize = nsize - buf->size; 195 size_t clrsize = nsize - buf->size;
196 DM_DBG(" clrsize=%" DM_PRIu_SIZE_T "\n", clrsize); 196 DM_DBG(" clrsize=%" DM_PRIu_SIZE_T "\n", clrsize);
209 memset(buf->data + buf->size, 0, clrsize); 209 memset(buf->data + buf->size, 0, clrsize);
210 } 210 }
211 211
212 buf->size = nsize; 212 buf->size = nsize;
213 213
214 return TRUE; 214 return true;
215 } 215 }
216 216
217 217
218 // 218 //
219 // Grow the buffer by "amount" bytes, but at least by buf->mingrow, 219 // Grow the buffer by "amount" bytes, but at least by buf->mingrow,
220 // if there is not enough space for at least that amount compared to 220 // if there is not enough space for at least that amount compared to
221 // current buffer "len". 221 // current buffer "len".
222 // 222 //
223 BOOL dmGrowBufGrow(DMGrowBuf *buf, const size_t amount) 223 bool dmGrowBufGrow(DMGrowBuf *buf, const size_t amount)
224 { 224 {
225 size_t grow = (amount > buf->mingrow) ? amount : buf->mingrow; 225 size_t grow = (amount > buf->mingrow) ? amount : buf->mingrow;
226 226
227 if (buf->is_const) 227 if (buf->is_const)
228 return FALSE; 228 return false;
229 229
230 if (buf->data == NULL || 230 if (buf->data == NULL ||
231 (buf->backwards && amount >= buf->offs) || 231 (buf->backwards && amount >= buf->offs) ||
232 (!buf->backwards && buf->offs + amount >= buf->size)) 232 (!buf->backwards && buf->offs + amount >= buf->size))
233 { 233 {
234 DM_DBG("dmGrowBufGrow(%p, amount=%" DM_PRIu_SIZE_T "): grow=%" DM_PRIu_SIZE_T "\n", 234 DM_DBG("dmGrowBufGrow(%p, amount=%" DM_PRIu_SIZE_T "): grow=%" DM_PRIu_SIZE_T "\n",
235 buf, amount, grow); 235 buf, amount, grow);
236 236
237 if (!dmGrowBufRealloc(buf, buf->size + grow, TRUE)) 237 if (!dmGrowBufRealloc(buf, buf->size + grow, true))
238 return FALSE; 238 return false;
239 } 239 }
240 240
241 buf->len += amount; 241 buf->len += amount;
242 return TRUE; 242 return true;
243 } 243 }
244 244
245 245
246 // 246 //
247 // Grow the buffer if "nsize" is larger than the current buffer size. 247 // Grow the buffer if "nsize" is larger than the current buffer size.
248 // Buffer is enlarged to nsize + mingrow. 248 // Buffer is enlarged to nsize + mingrow.
249 // 249 //
250 BOOL dmGrowBufCheckGrow(DMGrowBuf *buf, const size_t nsize) 250 bool dmGrowBufCheckGrow(DMGrowBuf *buf, const size_t nsize)
251 { 251 {
252 if (buf->is_const) 252 if (buf->is_const)
253 return FALSE; 253 return false;
254 254
255 if (buf->data == NULL || nsize > buf->size) 255 if (buf->data == NULL || nsize > buf->size)
256 { 256 {
257 if (!dmGrowBufRealloc(buf, nsize + buf->mingrow, TRUE)) 257 if (!dmGrowBufRealloc(buf, nsize + buf->mingrow, true))
258 return FALSE; 258 return false;
259 } 259 }
260 260
261 if (nsize > buf->len) 261 if (nsize > buf->len)
262 buf->len = nsize; 262 buf->len = nsize;
263 263
264 return TRUE; 264 return true;
265 } 265 }
266 266
267 267
268 BOOL dmGrowBufPut(DMGrowBuf *buf, const Uint8 *data, const size_t len) 268 bool dmGrowBufPut(DMGrowBuf *buf, const Uint8 *data, const size_t len)
269 { 269 {
270 if (data == NULL) 270 if (data == NULL)
271 return FALSE; 271 return false;
272 272
273 if (!dmGrowBufGrow(buf, len)) 273 if (!dmGrowBufGrow(buf, len))
274 return FALSE; 274 return false;
275 275
276 if (buf->backwards) 276 if (buf->backwards)
277 { 277 {
278 if (buf->literal) 278 if (buf->literal)
279 { 279 {
290 { 290 {
291 memcpy(buf->data + buf->offs, data, len); 291 memcpy(buf->data + buf->offs, data, len);
292 buf->offs += len; 292 buf->offs += len;
293 } 293 }
294 294
295 return TRUE; 295 return true;
296 } 296 }
297 297
298 298
299 BOOL dmGrowBufPutU8(DMGrowBuf *buf, const Uint8 value) 299 bool dmGrowBufPutU8(DMGrowBuf *buf, const Uint8 value)
300 { 300 {
301 if (!dmGrowBufGrow(buf, sizeof(Uint8))) 301 if (!dmGrowBufGrow(buf, sizeof(Uint8)))
302 return FALSE; 302 return false;
303 303
304 if (buf->backwards) 304 if (buf->backwards)
305 buf->data[--buf->offs] = value; 305 buf->data[--buf->offs] = value;
306 else 306 else
307 buf->data[buf->offs++] = value; 307 buf->data[buf->offs++] = value;
308 308
309 return TRUE; 309 return true;
310 } 310 }
311 311
312 312
313 BOOL dmGrowBufPutU16BE(DMGrowBuf *buf, const Uint16 val) 313 bool dmGrowBufPutU16BE(DMGrowBuf *buf, const Uint16 val)
314 { 314 {
315 if (buf->literal && buf->backwards) 315 if (buf->literal && buf->backwards)
316 { 316 {
317 return 317 return
318 dmGrowBufPutU8(buf, val & 0xff) && 318 dmGrowBufPutU8(buf, val & 0xff) &&
325 dmGrowBufPutU8(buf, val & 0xff); 325 dmGrowBufPutU8(buf, val & 0xff);
326 } 326 }
327 } 327 }
328 328
329 329
330 BOOL dmGrowBufPutU16LE(DMGrowBuf *buf, const Uint16 val) 330 bool dmGrowBufPutU16LE(DMGrowBuf *buf, const Uint16 val)
331 { 331 {
332 if (buf->literal && buf->backwards) 332 if (buf->literal && buf->backwards)
333 { 333 {
334 return 334 return
335 dmGrowBufPutU8(buf, (val >> 8) & 0xff) && 335 dmGrowBufPutU8(buf, (val >> 8) & 0xff) &&
342 dmGrowBufPutU8(buf, (val >> 8) & 0xff); 342 dmGrowBufPutU8(buf, (val >> 8) & 0xff);
343 } 343 }
344 } 344 }
345 345
346 346
347 BOOL dmGrowBufPutU32BE(DMGrowBuf *buf, const Uint32 val) 347 bool dmGrowBufPutU32BE(DMGrowBuf *buf, const Uint32 val)
348 { 348 {
349 if (buf->literal && buf->backwards) 349 if (buf->literal && buf->backwards)
350 { 350 {
351 return 351 return
352 dmGrowBufPutU8(buf, (val >> 24) & 0xff) && 352 dmGrowBufPutU8(buf, (val >> 24) & 0xff) &&
363 dmGrowBufPutU8(buf, (val >> 24) & 0xff); 363 dmGrowBufPutU8(buf, (val >> 24) & 0xff);
364 } 364 }
365 } 365 }
366 366
367 367
368 BOOL dmGrowBufPutU32LE(DMGrowBuf *buf, const Uint32 val) 368 bool dmGrowBufPutU32LE(DMGrowBuf *buf, const Uint32 val)
369 { 369 {
370 if (buf->literal && buf->backwards) 370 if (buf->literal && buf->backwards)
371 { 371 {
372 return 372 return
373 dmGrowBufPutU8(buf, val & 0xff) && 373 dmGrowBufPutU8(buf, val & 0xff) &&
384 dmGrowBufPutU8(buf, val & 0xff); 384 dmGrowBufPutU8(buf, val & 0xff);
385 } 385 }
386 } 386 }
387 387
388 388
389 BOOL dmGrowBufGetU8(DMGrowBuf *buf, Uint8 *value) 389 bool dmGrowBufGetU8(DMGrowBuf *buf, Uint8 *value)
390 { 390 {
391 if (buf->backwards) 391 if (buf->backwards)
392 { 392 {
393 if (buf->offs > 0) 393 if (buf->offs > 0)
394 *value = buf->data[--buf->offs]; 394 *value = buf->data[--buf->offs];
395 else 395 else
396 return FALSE; 396 return false;
397 } 397 }
398 else 398 else
399 { 399 {
400 if (buf->offs < buf->len) 400 if (buf->offs < buf->len)
401 *value = buf->data[buf->offs++]; 401 *value = buf->data[buf->offs++];
402 else 402 else
403 return FALSE; 403 return false;
404 } 404 }
405 405
406 return TRUE; 406 return true;
407 } 407 }