Strings and Text Processing

#include <stdio.h>
#include <string.h>

int main(void)
{
    const char *source = "hello";
    char destination[16];

    size_t length = strlen(source);          // 5 -- O(n), does not count the NUL

    // strcpy: no bounds check whatsoever. Only safe when you have PROVEN the fit.
    if (length + 1 <= sizeof destination) {
        strcpy(destination, source);
    }

    // strncpy is NOT a safe strcpy: it pads with NULs if shorter, and does NOT
    // terminate if the source is n bytes or longer.
    char fixed[4];
    strncpy(fixed, "abcdef", sizeof fixed);  // fixed is 'a','b','c','d' -- no NUL!
    fixed[sizeof fixed - 1] = '\0';          // you must terminate it yourself

    // snprintf is the actually-safe copy, and it always terminates:
    char safe[4];
    int needed = snprintf(safe, sizeof safe, "%s", "abcdef");
    printf("%s | %s | %s (needed %d, truncated=%d)\n",
           destination, fixed, safe, needed, (size_t)needed >= sizeof safe);
    return 0;
}

#include <stdio.h>
#include <string.h>

int main(void)
{
    char path[32] = "/var";

    // strcat appends and requires the caller to guarantee the room.
    if (strlen(path) + strlen("/log") + 1 <= sizeof path) {
        strcat(path, "/log");
    }

    // The idiom that replaces strcpy + strcat entirely, with one length check:
    char built[32];
    int written = snprintf(built, sizeof built, "%s/%s", "/var/log", "app.log");
    if (written < 0 || (size_t)written >= sizeof built) {
        fputs("path too long\n", stderr);
        return 1;
    }

    printf("%s | %s\n", path, built);
    return 0;
}

#include <stdio.h>
#include <string.h>

int main(void)
{
    const char *text = "the quick brown fox";

    // strcmp returns <0, 0 or >0 -- it is NOT a boolean.
    printf("%d %d %d\n",
           strcmp("abc", "abc") == 0,        // 1: equal
           strcmp("abc", "abd") < 0,         // 1: "abc" sorts first
           strncmp("abcdef", "abcxyz", 3) == 0);   // 1: first 3 bytes match

    const char *found = strchr(text, 'q');           // first 'q', or nullptr
    const char *last = strrchr(text, 'o');           // last 'o'
    const char *word = strstr(text, "brown");        // substring

    printf("%s | %s | %s\n",
           found != nullptr ? found : "(none)",
           last != nullptr ? last : "(none)",
           word != nullptr ? word : "(none)");

    // Spans: how many leading bytes are (or are not) in a set.
    printf("%zu %zu\n", strspn("128abc", "0123456789"), strcspn("abc=def", "="));
    return 0;
}

#include <stdio.h>
#include <string.h>

int main(void)
{
    // strtok WRITES to its input, so a literal would be undefined -- use an array.
    char input[] = "alpha,beta,,gamma";

    for (char *token = strtok(input, ","); token != nullptr; token = strtok(nullptr, ",")) {
        printf("[%s] ", token);          // note: consecutive delimiters are merged
    }
    putchar('\n');
    return 0;
}

#include <stdio.h>
#include <string.h>

int main(void)
{
    const char *input = "alpha,beta,,gamma";
    const char *cursor = input;

    while (*cursor != '\0') {
        size_t field_length = strcspn(cursor, ",");

        printf("[%.*s] ", (int)field_length, cursor);    // print without copying

        cursor += field_length;
        if (*cursor == ',') {
            ++cursor;                                    // step over the delimiter
        }
    }
    putchar('\n');
    return 0;
}

#include <stdio.h>
#include <string.h>

int main(void)
{
    unsigned char buffer[16];

    memset(buffer, 0, sizeof buffer);           // fill with a byte value

    const unsigned char source[4] = { 1, 2, 3, 4 };
    memcpy(buffer, source, sizeof source);      // regions must NOT overlap

    // Shift within one buffer -- overlapping, so memmove is required:
    memmove(buffer + 1, buffer, 4);

    printf("%d %d %d %d %d\n", buffer[0], buffer[1], buffer[2], buffer[3], buffer[4]);

    // memcmp compares BYTES, so it is right for buffers and wrong for structs
    // (padding bytes are indeterminate).
    printf("equal: %d\n", memcmp(source, source, sizeof source) == 0);

    const unsigned char *hit = memchr(buffer, 3, sizeof buffer);
    printf("found 3 at offset %td\n", hit != nullptr ? hit - buffer : -1);
    return 0;
}

#include <string.h>

static void handle_secret(void)
{
    unsigned char key[32];
    /* ... use the key ... */

    memset_explicit(key, 0, sizeof key);    // C23: guaranteed not to be elided
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    // C23 standardizes both (POSIX had them for decades). The caller owns the result.
    char *copy = strdup("hello");
    char *prefix = strndup("hello world", 5);

    if (copy == nullptr || prefix == nullptr) {
        free(copy);
        free(prefix);
        return EXIT_FAILURE;
    }

    printf("%s | %s\n", copy, prefix);
    free(copy);
    free(prefix);
    return 0;
}

#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <uchar.h>

int main(void)
{
    setlocale(LC_CTYPE, "");                // conversion depends on LC_CTYPE

    const char *input = "café";
    size_t remaining = strlen(input) + 1;   // include the terminator: it ends the loop
    const char *cursor = input;

    mbstate_t state;
    memset(&state, 0, sizeof state);        // a fresh conversion state

    char32_t code_point;
    size_t consumed;

    while ((consumed = mbrtoc32(&code_point, cursor, remaining, &state)) != 0) {
        if (consumed == (size_t)-1 || consumed == (size_t)-2) {
            fputs("invalid or incomplete multibyte sequence\n", stderr);
            return 1;
        }
        if (consumed == (size_t)-3) {
            continue;                       // another code unit from the same character
        }

        printf("U+%04X ", (unsigned)code_point);
        cursor += consumed;
        remaining -= consumed;
    }
    putchar('\n');

    // The reverse direction, plus the wide-character equivalents in <wchar.h>:
    char out[MB_CUR_MAX];
    memset(&state, 0, sizeof state);
    size_t produced = c32rtomb(out, U'é', &state);
    printf("encoded %zu bytes\n", produced);
    return 0;
}