/* Three ways to leave nested loops after finding a value in a 2-D table.
   All three give the same answer; what differs is how easily a reader
   follows the flow. */
#include <stdbool.h>
#include <stdio.h>

#define ROWS 4
#define COLS 5

static const int grid[ROWS][COLS] = {
    {  3, 14, 15,  92,  6 },
    { 53, 58,  9,  79,  3 },
    { 23, 84, 62,  64, 33 },
    { 83, 27, 95,  28, 84 },
};

struct pos { int row, col; bool found; };

/* -- 1. a flag variable --
   The flag rides on the outer loop's condition. Plain standard C, but the
   condition grows and "where it ended" is scattered over two places. */
static struct pos find_flag(int target)
{
    struct pos p = { -1, -1, false };
    for (int i = 0; i < ROWS && !p.found; i++)
        for (int j = 0; j < COLS; j++)
            if (grid[i][j] == target) { p.row = i; p.col = j; p.found = true; break; }
    return p;
}

/* -- 2. goto --
   "shed both layers at once" shows in a single line.
   The label goes below, and is named for what it does. */
static struct pos find_goto(int target)
{
    struct pos p = { -1, -1, false };
    for (int i = 0; i < ROWS; i++)
        for (int j = 0; j < COLS; j++)
            if (grid[i][j] == target) { p.row = i; p.col = j; p.found = true; goto done; }
done:
    return p;
}

/* -- 3. lift it into a function and return --
   return sheds any number of layers at once; no escape device is needed. */
static struct pos find_return(int target)
{
    for (int i = 0; i < ROWS; i++)
        for (int j = 0; j < COLS; j++)
            if (grid[i][j] == target) return (struct pos){ i, j, true };
    return (struct pos){ -1, -1, false };
}

static void show(const char *how, struct pos p)
{
    if (p.found) printf("  %-18s (%d, %d)\n", how, p.row, p.col);
    else         printf("  %-18s not found\n", how);
}

int main(void)
{
    puts("[looking for 62 — the three ways agree]");
    show("1. flag", find_flag(62));
    show("2. goto", find_goto(62));
    show("3. function+return", find_return(62));

    puts("\n[looking for a value that is not there (100)]");
    show("1. flag", find_flag(100));
    show("2. goto", find_goto(100));
    show("3. function+return", find_return(100));

    puts("\n[break sheds one layer only — hence the devices above]");
    int visited = 0;
    for (int i = 0; i < ROWS; i++)
        for (int j = 0; j < COLS; j++) { visited++; if (grid[i][j] == 62) break; }
    printf("  break in the inner loop only: visited %d cells (of %d)\n",
           visited, ROWS * COLS);
    puts("  -> only the inner loop ended; the outer one kept going.");
    return 0;
}

/* do { } while (0), which makes a macro one statement — and cleanup by goto. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* With braces alone, the trailing semicolon makes it two statements,
   so putting it between if and else is a compile error:

       #define SWAP_BAD(a, b) { int t = (a); (a) = (b); (b) = t; }
       if (x < y) SWAP_BAD(x, y); else puts("...");
           → error: 'else' without a previous 'if'

   do { } while (0) makes it a braced block and a single statement at once. */
#define SWAP(a, b)  do { int t_ = (a); (a) = (b); (b) = t_; } while (0)

#define LOG(fmt, ...)  do {                       \
        printf("[log] " fmt "\n", __VA_ARGS__);   \
    } while (0)

/* Gathering the cleanup in one place with goto — the Linux kernel's shape.
   Fail midway and only what was acquired so far is given back. */
static bool build(size_t n, bool fail_at_second)
{
    char *a = nullptr, *b = nullptr;
    bool ok = false;

    a = malloc(n);
    if (!a) goto out;                 /* nothing to give back yet */
    memset(a, 'a', n);

    b = fail_at_second ? nullptr : malloc(n);
    if (!b) goto free_a;              /* give back only a */
    memset(b, 'b', n);

    ok = true;

    free(b);
free_a:
    free(a);
out:
    return ok;
}

int main(void)
{
    int x = 1, y = 2;

    puts("[do { } while (0) — the macro becomes one statement]");
    if (x < y) SWAP(x, y); else puts("  (we do not come here)");
    printf("  after the swap: x=%d y=%d   <- unbroken between if and else\n", x, y);

    LOG("values %d and %d", x, y);

    puts("\n[safe as a for body without braces, too]");
    for (int i = 0; i < 2; i++)
        LOG("iteration %d", i);

    puts("\n[gathering cleanup with goto]");
    printf("  both succeed: %s\n", build(16, false) ? "ok" : "failed");
    printf("  second one fails: %s  <- only the first was given back\n",
           build(16, true) ? "ok" : "failed");
    return 0;
}

/* A few loop idioms — and the places that bite quietly. */
#include <stddef.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    int a[] = { 10, 20, 30, 40, 50 };
    size_t n = sizeof a / sizeof a[0];

    puts("[walking backwards — with size_t you cannot write i >= 0]");
    printf("  the right shape (i-- > 0): ");
    for (size_t i = n; i-- > 0; ) printf("%d ", a[i]);
    puts("");
    puts("  the wrong shape (size_t i = n-1; i >= 0; i--) loops forever —");
    puts("  after 0 an unsigned value wraps to SIZE_MAX, so the test never fails.");
    printf("  with a signed index that shape works too: ");
    for (int i = (int)n - 1; i >= 0; i--) printf("%d ", a[i]);
    puts("");

    puts("\n[the comma operator — closing in from both ends]");
    printf("  reversed: ");
    int b[] = { 1, 2, 3, 4, 5, 6 };
    size_t m = sizeof b / sizeof b[0];
    for (size_t i = 0, j = m - 1; i < j; i++, j--) {
        int t = b[i]; b[i] = b[j]; b[j] = t;
    }
    for (size_t i = 0; i < m; i++) printf("%d ", b[i]);
    puts("");

    puts("\n[a sentinel loop — read and test in one breath]");
    const char *text = "hi!\n";
    const char *p = text;
    int c, count = 0;
    while ((c = *p++) != '\0') {          /* the parentheses are required */
        if (c == '\n') printf("\\n ");
        else printf("%c ", c);
        count++;
    }
    printf("\n  read %d characters\n", count);

    puts("\n[do not call strlen in the loop condition]");
    const char *s = "measure once";
    size_t len = strlen(s);               /* measured once */
    size_t vowels = 0;
    for (size_t i = 0; i < len; i++)
        if (strchr("aeiou", s[i]) && s[i]) vowels++;
    printf("  \"%s\" has %zu vowels (length %zu, measured once)\n", s, vowels, len);

    puts("\n[write the intent when a body is empty]");
    size_t skip = 0;
    const char *q = "   value";
    while (q[skip] == ' ')
        skip++;                            /* written with a body */
    printf("  skipped %zu leading spaces\n", skip);
    puts("  while (q[skip++] == ' ') ;  is shorter, but that lone");
    puts("  semicolon goes unnoticed, and that is where accidents come from.");
    return 0;
}