Mercurial > hg > th-libs

comparison th_datastruct.c @ 453:efd33accdc81

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Break backwards compatibility by renaming BOOL, TRUE and FALSE to lowercase. Introduce optional but default use of stdbool.h.
author Matti Hamalainen <ccr@tnsp.org>
date Tue, 02 Jan 2018 22:56:03 +0200
parents 6d29aaeab290
children 347bfd3e017e
comparison
equal deleted inserted replaced
452:4471eadea472 453:efd33accdc81
333 333
334 return res; 334 return res;
335 } 335 }
336 336
337 337
338 BOOL th_ringbuf_grow(th_ringbuf_t *buf, const size_t n) 338 bool th_ringbuf_grow(th_ringbuf_t *buf, const size_t n)
339 { 339 {
340 buf->data = (char **) th_realloc(buf->data, (buf->size + n) * sizeof(char *)); 340 buf->data = (char **) th_realloc(buf->data, (buf->size + n) * sizeof(char *));
341 if (buf->data != NULL) 341 if (buf->data != NULL)
342 { 342 {
343 memset(buf->data + buf->size, 0, sizeof(char *) * n); 343 memset(buf->data + buf->size, 0, sizeof(char *) * n);
344 buf->size += n; 344 buf->size += n;
345 return TRUE; 345 return true;
346 } else 346 } else
347 return FALSE; 347 return false;
348 } 348 }
349 349
350 350
351 void th_ringbuf_free(th_ringbuf_t *buf) 351 void th_ringbuf_free(th_ringbuf_t *buf)
352 { 352 {
398 398
399 if ((buf = th_malloc(sizeof(th_growbuf_t))) == NULL) 399 if ((buf = th_malloc(sizeof(th_growbuf_t))) == NULL)
400 return NULL; 400 return NULL;
401 401
402 th_growbuf_init(buf, mingrow); 402 th_growbuf_init(buf, mingrow);
403 buf->allocated = TRUE; 403 buf->allocated = true;
404 404
405 return buf; 405 return buf;
406 } 406 }
407 407
408 408
413 if (buf->allocated) 413 if (buf->allocated)
414 th_free(buf); 414 th_free(buf);
415 } 415 }
416 416
417 417
418 BOOL th_growbuf_grow(th_growbuf_t *buf, const size_t grow) 418 bool th_growbuf_grow(th_growbuf_t *buf, const size_t grow)
419 { 419 {
420 if (buf == NULL) 420 if (buf == NULL)
421 return FALSE; 421 return false;
422 422
423 if (buf->data == NULL || buf->len + grow >= buf->size) 423 if (buf->data == NULL || buf->len + grow >= buf->size)
424 { 424 {
425 buf->size += grow + (buf->mingrow > 0 ? buf->mingrow : TH_BUFGROW); 425 buf->size += grow + (buf->mingrow > 0 ? buf->mingrow : TH_BUFGROW);
426 buf->data = (uint8_t *) th_realloc(buf->data, buf->size); 426 buf->data = (uint8_t *) th_realloc(buf->data, buf->size);
427 if (buf->data == NULL) 427 if (buf->data == NULL)
428 return FALSE; 428 return false;
429 } 429 }
430 return TRUE; 430 return true;
431 } 431 }
432 432
433 433
434 BOOL th_growbuf_puts(th_growbuf_t *buf, const char *str, BOOL eos) 434 bool th_growbuf_puts(th_growbuf_t *buf, const char *str, bool eos)
435 { 435 {
436 size_t slen; 436 size_t slen;
437 if (str == NULL) 437 if (str == NULL)
438 return FALSE; 438 return false;
439 439
440 slen = strlen(str); 440 slen = strlen(str);
441 if (!th_growbuf_grow(buf, slen + 1)) 441 if (!th_growbuf_grow(buf, slen + 1))
442 return FALSE; 442 return false;
443 443
444 memcpy(buf->data + buf->len, str, slen + 1); 444 memcpy(buf->data + buf->len, str, slen + 1);
445 buf->len += eos ? (slen + 1) : slen; 445 buf->len += eos ? (slen + 1) : slen;
446 446
447 return TRUE; 447 return true;
448 } 448 }
449 449
450 450
451 BOOL th_growbuf_putch(th_growbuf_t *buf, const char ch) 451 bool th_growbuf_putch(th_growbuf_t *buf, const char ch)
452 { 452 {
453 if (!th_growbuf_grow(buf, sizeof(char))) 453 if (!th_growbuf_grow(buf, sizeof(char)))
454 return FALSE; 454 return false;
455 455
456 buf->data[buf->len++] = (uint8_t) ch; 456 buf->data[buf->len++] = (uint8_t) ch;
457 457
458 return TRUE; 458 return true;
459 } 459 }
460 460
461 461
462 BOOL th_growbuf_put_str(th_growbuf_t *buf, const void *s, const size_t len) 462 bool th_growbuf_put_str(th_growbuf_t *buf, const void *s, const size_t len)
463 { 463 {
464 if (s == NULL) 464 if (s == NULL)
465 return FALSE; 465 return false;
466 466
467 if (!th_growbuf_grow(buf, len + 1)) 467 if (!th_growbuf_grow(buf, len + 1))
468 return FALSE; 468 return false;
469 469
470 memcpy(buf->data + buf->len, s, len + 1); 470 memcpy(buf->data + buf->len, s, len + 1);
471 buf->len += len; 471 buf->len += len;
472 472
473 return TRUE; 473 return true;
474 } 474 }
475 475
476 476
477 BOOL th_growbuf_put_u8(th_growbuf_t *buf, const uint8_t val) 477 bool th_growbuf_put_u8(th_growbuf_t *buf, const uint8_t val)
478 { 478 {
479 if (!th_growbuf_grow(buf, sizeof(uint8_t))) 479 if (!th_growbuf_grow(buf, sizeof(uint8_t)))
480 return FALSE; 480 return false;
481 481
482 buf->data[buf->len++] = val; 482 buf->data[buf->len++] = val;
483 483
484 return TRUE; 484 return true;
485 } 485 }
486 486
487 487
488 BOOL th_growbuf_put_u16_be(th_growbuf_t *buf, const uint16_t val) 488 bool th_growbuf_put_u16_be(th_growbuf_t *buf, const uint16_t val)
489 { 489 {
490 if (!th_growbuf_grow(buf, sizeof(uint16_t))) 490 if (!th_growbuf_grow(buf, sizeof(uint16_t)))
491 return FALSE; 491 return false;
492 492
493 buf->data[buf->len++] = (val >> 8) & 0xff; 493 buf->data[buf->len++] = (val >> 8) & 0xff;
494 buf->data[buf->len++] = val & 0xff; 494 buf->data[buf->len++] = val & 0xff;
495 495
496 return TRUE; 496 return true;
497 } 497 }
498 498
499 499
500 BOOL th_growbuf_put_u16_le(th_growbuf_t *buf, const uint16_t val) 500 bool th_growbuf_put_u16_le(th_growbuf_t *buf, const uint16_t val)
501 { 501 {
502 if (!th_growbuf_grow(buf, sizeof(uint16_t))) 502 if (!th_growbuf_grow(buf, sizeof(uint16_t)))
503 return FALSE; 503 return false;
504 504
505 buf->data[buf->len++] = val & 0xff; 505 buf->data[buf->len++] = val & 0xff;
506 buf->data[buf->len++] = (val >> 8) & 0xff; 506 buf->data[buf->len++] = (val >> 8) & 0xff;
507 507
508 return TRUE; 508 return true;
509 } 509 }
510 510
511 511
512 BOOL th_growbuf_put_u32_be(th_growbuf_t *buf, const uint32_t val) 512 bool th_growbuf_put_u32_be(th_growbuf_t *buf, const uint32_t val)
513 { 513 {
514 if (!th_growbuf_grow(buf, sizeof(uint32_t))) 514 if (!th_growbuf_grow(buf, sizeof(uint32_t)))
515 return FALSE; 515 return false;
516 516
517 buf->data[buf->len++] = (val >> 24) & 0xff; 517 buf->data[buf->len++] = (val >> 24) & 0xff;
518 buf->data[buf->len++] = (val >> 16) & 0xff; 518 buf->data[buf->len++] = (val >> 16) & 0xff;
519 buf->data[buf->len++] = (val >> 8) & 0xff; 519 buf->data[buf->len++] = (val >> 8) & 0xff;
520 buf->data[buf->len++] = val & 0xff; 520 buf->data[buf->len++] = val & 0xff;
521 521
522 return TRUE; 522 return true;
523 } 523 }
524 524
525 525
526 BOOL th_growbuf_put_u32_le(th_growbuf_t *buf, const uint32_t val) 526 bool th_growbuf_put_u32_le(th_growbuf_t *buf, const uint32_t val)
527 { 527 {
528 if (!th_growbuf_grow(buf, sizeof(uint32_t))) 528 if (!th_growbuf_grow(buf, sizeof(uint32_t)))
529 return FALSE; 529 return false;
530 530
531 buf->data[buf->len++] = val & 0xff; 531 buf->data[buf->len++] = val & 0xff;
532 buf->data[buf->len++] = (val >> 8) & 0xff; 532 buf->data[buf->len++] = (val >> 8) & 0xff;
533 buf->data[buf->len++] = (val >> 16) & 0xff; 533 buf->data[buf->len++] = (val >> 16) & 0xff;
534 buf->data[buf->len++] = (val >> 24) & 0xff; 534 buf->data[buf->len++] = (val >> 24) & 0xff;
535 535
536 return TRUE; 536 return true;
537 } 537 }
538 538
539 539
540 /* 540 /*
541 * Simple legacy string growing buffer 541 * Simple legacy string growing buffer
542 */ 542 */
543 BOOL th_strbuf_grow(char **buf, size_t *bufsize, size_t *len, size_t grow) 543 bool th_strbuf_grow(char **buf, size_t *bufsize, size_t *len, size_t grow)
544 { 544 {
545 if (*buf == NULL) 545 if (*buf == NULL)
546 *bufsize = *len = 0; 546 *bufsize = *len = 0;
547 547
548 if (*buf == NULL || *len + grow >= *bufsize) 548 if (*buf == NULL || *len + grow >= *bufsize)
549 { 549 {
550 *bufsize += grow + TH_BUFGROW; 550 *bufsize += grow + TH_BUFGROW;
551 *buf = th_realloc(*buf, *bufsize); 551 *buf = th_realloc(*buf, *bufsize);
552 if (*buf == NULL) 552 if (*buf == NULL)
553 return FALSE; 553 return false;
554 } 554 }
555 return TRUE; 555 return true;
556 } 556 }
557 557
558 558
559 BOOL th_strbuf_putch(char **buf, size_t *bufsize, size_t *len, const char ch) 559 bool th_strbuf_putch(char **buf, size_t *bufsize, size_t *len, const char ch)
560 { 560 {
561 if (!th_strbuf_grow(buf, bufsize, len, 1)) 561 if (!th_strbuf_grow(buf, bufsize, len, 1))
562 return FALSE; 562 return false;
563 563
564 (*buf)[*len] = ch; 564 (*buf)[*len] = ch;
565 (*len)++; 565 (*len)++;
566 566
567 return TRUE; 567 return true;
568 } 568 }
569 569
570 570
571 BOOL th_strbuf_putsn(char **buf, size_t *bufsize, size_t *len, const char *str, const size_t slen) 571 bool th_strbuf_putsn(char **buf, size_t *bufsize, size_t *len, const char *str, const size_t slen)
572 { 572 {
573 if (str == NULL) 573 if (str == NULL)
574 return FALSE; 574 return false;
575 575
576 if (!th_strbuf_grow(buf, bufsize, len, slen + 1)) 576 if (!th_strbuf_grow(buf, bufsize, len, slen + 1))
577 return FALSE; 577 return false;
578 578
579 memcpy(*buf + *len, str, slen); 579 memcpy(*buf + *len, str, slen);
580 (*len) += slen; 580 (*len) += slen;
581 *(buf + *len + slen) = 0; 581 *(buf + *len + slen) = 0;
582 582
583 return TRUE; 583 return true;
584 } 584 }
585 585
586 586
587 BOOL th_strbuf_puts(char **buf, size_t *bufsize, size_t *len, const char *str) 587 bool th_strbuf_puts(char **buf, size_t *bufsize, size_t *len, const char *str)
588 { 588 {
589 size_t slen; 589 size_t slen;
590 if (str == NULL) 590 if (str == NULL)
591 return FALSE; 591 return false;
592 592
593 slen = strlen(str); 593 slen = strlen(str);
594 if (!th_strbuf_grow(buf, bufsize, len, slen + 1)) 594 if (!th_strbuf_grow(buf, bufsize, len, slen + 1))
595 return FALSE; 595 return false;
596 596
597 memcpy(*buf + *len, str, slen + 1); 597 memcpy(*buf + *len, str, slen + 1);
598 (*len) += slen; 598 (*len) += slen;
599 599
600 return TRUE; 600 return true;
601 } 601 }