Mercurial > hg > th-libs

comparison th_datastruct.c @ 735:31bc1ed07cf5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Renaming BOOL->bool and TRUE/FALSE to true/false, and using stdbool.h if available.
author Matti Hamalainen <ccr@tnsp.org>
date Wed, 07 Dec 2022 12:14:39 +0200
parents 79d06eb6d39f
children ca837a4417f5
comparison
equal deleted inserted replaced
734:2ae1045f6c18 735:31bc1ed07cf5
316 { 316 {
317 th_free(*buf); 317 th_free(*buf);
318 return res; 318 return res;
319 } 319 }
320 320
321 (*buf)->is_allocated = TRUE; 321 (*buf)->is_allocated = true;
322 322
323 return THERR_OK; 323 return THERR_OK;
324 } 324 }
325 325
326 326
389 389
390 if ((buf = th_malloc(sizeof(th_growbuf_t))) == NULL) 390 if ((buf = th_malloc(sizeof(th_growbuf_t))) == NULL)
391 return NULL; 391 return NULL;
392 392
393 th_growbuf_init(buf, mingrow); 393 th_growbuf_init(buf, mingrow);
394 buf->is_allocated = TRUE; 394 buf->is_allocated = true;
395 395
396 return buf; 396 return buf;
397 } 397 }
398 398
399 399
404 if (buf->is_allocated) 404 if (buf->is_allocated)
405 th_free(buf); 405 th_free(buf);
406 } 406 }
407 407
408 408
409 BOOL th_growbuf_grow(th_growbuf_t *buf, const size_t amount) 409 bool th_growbuf_grow(th_growbuf_t *buf, const size_t amount)
410 { 410 {
411 if (buf == NULL) 411 if (buf == NULL)
412 return FALSE; 412 return false;
413 413
414 if (buf->data == NULL || buf->len + amount >= buf->size) 414 if (buf->data == NULL || buf->len + amount >= buf->size)
415 { 415 {
416 buf->size += amount + (buf->mingrow > 0 ? buf->mingrow : TH_BUFGROW); 416 buf->size += amount + (buf->mingrow > 0 ? buf->mingrow : TH_BUFGROW);
417 if ((buf->data = th_realloc(buf->data, buf->size)) == NULL) 417 if ((buf->data = th_realloc(buf->data, buf->size)) == NULL)
418 return FALSE; 418 return false;
419 } 419 }
420 return TRUE; 420 return true;
421 } 421 }
422 422
423 423
424 BOOL th_growbuf_puts(th_growbuf_t *buf, const char *str, BOOL eos) 424 bool th_growbuf_puts(th_growbuf_t *buf, const char *str, bool eos)
425 { 425 {
426 size_t slen; 426 size_t slen;
427 if (str == NULL) 427 if (str == NULL)
428 return FALSE; 428 return false;
429 429
430 slen = strlen(str); 430 slen = strlen(str);
431 if (!th_growbuf_grow(buf, slen + 1)) 431 if (!th_growbuf_grow(buf, slen + 1))
432 return FALSE; 432 return false;
433 433
434 memcpy(buf->data + buf->len, str, slen + 1); 434 memcpy(buf->data + buf->len, str, slen + 1);
435 buf->len += eos ? (slen + 1) : slen; 435 buf->len += eos ? (slen + 1) : slen;
436 436
437 return TRUE; 437 return true;
438 } 438 }
439 439
440 440
441 BOOL th_growbuf_putch(th_growbuf_t *buf, const char ch) 441 bool th_growbuf_putch(th_growbuf_t *buf, const char ch)
442 { 442 {
443 if (!th_growbuf_grow(buf, sizeof(char))) 443 if (!th_growbuf_grow(buf, sizeof(char)))
444 return FALSE; 444 return false;
445 445
446 buf->data[buf->len++] = (uint8_t) ch; 446 buf->data[buf->len++] = (uint8_t) ch;
447 447
448 return TRUE; 448 return true;
449 } 449 }
450 450
451 451
452 BOOL th_growbuf_put_str(th_growbuf_t *buf, const void *str, const size_t len) 452 bool th_growbuf_put_str(th_growbuf_t *buf, const void *str, const size_t len)
453 { 453 {
454 if (str == NULL) 454 if (str == NULL)
455 return FALSE; 455 return false;
456 456
457 if (!th_growbuf_grow(buf, len + 1)) 457 if (!th_growbuf_grow(buf, len + 1))
458 return FALSE; 458 return false;
459 459
460 memcpy(buf->data + buf->len, str, len + 1); 460 memcpy(buf->data + buf->len, str, len + 1);
461 buf->len += len; 461 buf->len += len;
462 462
463 return TRUE; 463 return true;
464 } 464 }
465 465
466 466
467 BOOL th_growbuf_put_u8(th_growbuf_t *buf, const uint8_t val) 467 bool th_growbuf_put_u8(th_growbuf_t *buf, const uint8_t val)
468 { 468 {
469 if (!th_growbuf_grow(buf, sizeof(uint8_t))) 469 if (!th_growbuf_grow(buf, sizeof(uint8_t)))
470 return FALSE; 470 return false;
471 471
472 buf->data[buf->len++] = val; 472 buf->data[buf->len++] = val;
473 473
474 return TRUE; 474 return true;
475 } 475 }
476 476
477 477
478 BOOL th_growbuf_put_u16_be(th_growbuf_t *buf, const uint16_t val) 478 bool th_growbuf_put_u16_be(th_growbuf_t *buf, const uint16_t val)
479 { 479 {
480 if (!th_growbuf_grow(buf, sizeof(uint16_t))) 480 if (!th_growbuf_grow(buf, sizeof(uint16_t)))
481 return FALSE; 481 return false;
482 482
483 buf->data[buf->len++] = (val >> 8) & 0xff; 483 buf->data[buf->len++] = (val >> 8) & 0xff;
484 buf->data[buf->len++] = val & 0xff; 484 buf->data[buf->len++] = val & 0xff;
485 485
486 return TRUE; 486 return true;
487 } 487 }
488 488
489 489
490 BOOL th_growbuf_put_u16_le(th_growbuf_t *buf, const uint16_t val) 490 bool th_growbuf_put_u16_le(th_growbuf_t *buf, const uint16_t val)
491 { 491 {
492 if (!th_growbuf_grow(buf, sizeof(uint16_t))) 492 if (!th_growbuf_grow(buf, sizeof(uint16_t)))
493 return FALSE; 493 return false;
494 494
495 buf->data[buf->len++] = val & 0xff; 495 buf->data[buf->len++] = val & 0xff;
496 buf->data[buf->len++] = (val >> 8) & 0xff; 496 buf->data[buf->len++] = (val >> 8) & 0xff;
497 497
498 return TRUE; 498 return true;
499 } 499 }
500 500
501 501
502 BOOL th_growbuf_put_u32_be(th_growbuf_t *buf, const uint32_t val) 502 bool th_growbuf_put_u32_be(th_growbuf_t *buf, const uint32_t val)
503 { 503 {
504 if (!th_growbuf_grow(buf, sizeof(uint32_t))) 504 if (!th_growbuf_grow(buf, sizeof(uint32_t)))
505 return FALSE; 505 return false;
506 506
507 buf->data[buf->len++] = (val >> 24) & 0xff; 507 buf->data[buf->len++] = (val >> 24) & 0xff;
508 buf->data[buf->len++] = (val >> 16) & 0xff; 508 buf->data[buf->len++] = (val >> 16) & 0xff;
509 buf->data[buf->len++] = (val >> 8) & 0xff; 509 buf->data[buf->len++] = (val >> 8) & 0xff;
510 buf->data[buf->len++] = val & 0xff; 510 buf->data[buf->len++] = val & 0xff;
511 511
512 return TRUE; 512 return true;
513 } 513 }
514 514
515 515
516 BOOL th_growbuf_put_u32_le(th_growbuf_t *buf, const uint32_t val) 516 bool th_growbuf_put_u32_le(th_growbuf_t *buf, const uint32_t val)
517 { 517 {
518 if (!th_growbuf_grow(buf, sizeof(uint32_t))) 518 if (!th_growbuf_grow(buf, sizeof(uint32_t)))
519 return FALSE; 519 return false;
520 520
521 buf->data[buf->len++] = val & 0xff; 521 buf->data[buf->len++] = val & 0xff;
522 buf->data[buf->len++] = (val >> 8) & 0xff; 522 buf->data[buf->len++] = (val >> 8) & 0xff;
523 buf->data[buf->len++] = (val >> 16) & 0xff; 523 buf->data[buf->len++] = (val >> 16) & 0xff;
524 buf->data[buf->len++] = (val >> 24) & 0xff; 524 buf->data[buf->len++] = (val >> 24) & 0xff;
525 525
526 return TRUE; 526 return true;
527 } 527 }
528 528
529 529
530 /* 530 /*
531 * Simple legacy string growing buffer 531 * Simple legacy string growing buffer
532 */ 532 */
533 BOOL th_strbuf_grow(char **buf, size_t *bufsize, size_t *len, size_t grow) 533 bool th_strbuf_grow(char **buf, size_t *bufsize, size_t *len, size_t grow)
534 { 534 {
535 if (*buf == NULL) 535 if (*buf == NULL)
536 *bufsize = *len = 0; 536 *bufsize = *len = 0;
537 537
538 if (*buf == NULL || *len + grow >= *bufsize) 538 if (*buf == NULL || *len + grow >= *bufsize)
539 { 539 {
540 *bufsize += grow + TH_BUFGROW; 540 *bufsize += grow + TH_BUFGROW;
541 *buf = th_realloc(*buf, *bufsize); 541 *buf = th_realloc(*buf, *bufsize);
542 if (*buf == NULL) 542 if (*buf == NULL)
543 return FALSE; 543 return false;
544 } 544 }
545 return TRUE; 545 return true;
546 } 546 }
547 547
548 548
549 BOOL th_strbuf_putch(char **buf, size_t *bufsize, size_t *len, const uint8_t ch) 549 bool th_strbuf_putch(char **buf, size_t *bufsize, size_t *len, const uint8_t ch)
550 { 550 {
551 if (!th_strbuf_grow(buf, bufsize, len, 1)) 551 if (!th_strbuf_grow(buf, bufsize, len, 1))
552 return FALSE; 552 return false;
553 553
554 (*buf)[*len] = ch; 554 (*buf)[*len] = ch;
555 (*len)++; 555 (*len)++;
556 556
557 return TRUE; 557 return true;
558 } 558 }
559 559
560 560
561 BOOL th_strbuf_putsn(char **buf, size_t *bufsize, size_t *len, const char *str, const size_t slen) 561 bool th_strbuf_putsn(char **buf, size_t *bufsize, size_t *len, const char *str, const size_t slen)
562 { 562 {
563 if (str == NULL) 563 if (str == NULL)
564 return FALSE; 564 return false;
565 565
566 if (!th_strbuf_grow(buf, bufsize, len, slen + 1)) 566 if (!th_strbuf_grow(buf, bufsize, len, slen + 1))
567 return FALSE; 567 return false;
568 568
569 memcpy(*buf + *len, str, slen); 569 memcpy(*buf + *len, str, slen);
570 (*len) += slen; 570 (*len) += slen;
571 *(buf + *len + slen) = 0; 571 *(buf + *len + slen) = 0;
572 572
573 return TRUE; 573 return true;
574 } 574 }
575 575
576 576
577 BOOL th_strbuf_puts(char **buf, size_t *bufsize, size_t *len, const char *str) 577 bool th_strbuf_puts(char **buf, size_t *bufsize, size_t *len, const char *str)
578 { 578 {
579 size_t slen; 579 size_t slen;
580 if (str == NULL) 580 if (str == NULL)
581 return FALSE; 581 return false;
582 582
583 slen = strlen(str); 583 slen = strlen(str);
584 if (!th_strbuf_grow(buf, bufsize, len, slen + 1)) 584 if (!th_strbuf_grow(buf, bufsize, len, slen + 1))
585 return FALSE; 585 return false;
586 586
587 memcpy(*buf + *len, str, slen + 1); 587 memcpy(*buf + *len, str, slen + 1);
588 (*len) += slen; 588 (*len) += slen;
589 589
590 return TRUE; 590 return true;
591 } 591 }