// TRAP — == binds tighter than &
val & 0x01 == 0      // → val & (0x01==0) → val & 0 → always 0!
(val & 0x01) == 0    // correct

// TRAP — postfix++ beats *
*p++    // → *(p++) — deref old p, then advance
(*p)++  // increment the value p points to

const int *p1 = &x;        // pointer to const int
int *const p2 = &x;        // const pointer to int
const int *const p3 = &x;  // const pointer to const int

// Macros (Linux kernel style)
#define BIT(n)       (1u << (n))
#define GENMASK(h,l) (((1u << ((h)-(l)+1))-1) << (l))

val |=  (1u << n);           // SET bit n
val &= ~(1u << n);           // CLEAR bit n
val ^=  (1u << n);           // TOGGLE bit n

// SET bits 3–7 to 'mode' — raw, no macros
val = (val & ~(0x1Fu << 3)) | ((mode & 0x1Fu) << 3);
//    step 1: build mask → shift to pos 3 → negate → AND (clears bits 3-7)
//    step 2: shift mode to pos 3 → OR (writes new value)

// READ bits 3–7
uint32_t m = (*reg >> 3) & 0x1F;

// Bad — 12 bytes (wasted padding)
struct foo { char a; int b; char c; };
// offsets: a=0, [3B pad], b=4, c=8, [3B pad] = 12B

// Good — 8 bytes (largest field first)
struct bar { int b; char a; char c; };
// offsets: b=0, a=4, c=5, [2B pad] = 8B

// Endianness test
uint32_t x = 0x12345678;
uint8_t *p = (uint8_t *)&x;
if (*p == 0x78) puts("little endian");
else             puts("big endian");

htonl(val);   // host → network (big endian)
ntohl(val);   // network → host

// Bad — compiler caches the read at -O2
uint32_t *reg = (uint32_t *)0x40011004;
while (*reg & 0x01 == 0);    // also a precedence bug!

// Correct
volatile uint32_t *reg = (volatile uint32_t *)0x40011004;
while ((*reg & 0x01) == 0);  // fresh load every iteration

// PACKED — removes padding between fields
struct __attribute__((packed)) pkt {
    uint8_t  magic;   // offset 0
    uint32_t seq;     // offset 1 — no padding inserted
};  // sizeof = 5

// BITFIELD — controls field size in bits
struct uart_reg {
    uint32_t enable   : 1;   // 1 bit,  values 0–1
    uint32_t mode     : 3;   // 3 bits, values 0–7
    uint32_t baud     : 4;   // 4 bits, values 0–15
    uint32_t reserved : 24;  // 24 bits — 1+3+4+24 = 32 total
};  // sizeof = 4

// ; is a sequence point — side effects committed before next statement
printf("%d ", *p++);   // ok — p++ committed after ;
printf("%d ", *p++);   // ok — p already advanced
printf("%d\n", *p);    // ok — no modification

int a[] = {1,2,3,4,5};
int *p = &a[1];   // points to a[1]
int *q = &a[4];   // points to a[4]

q - p;   // → 3  (elements, not bytes!)  type: ptrdiff_t
p + 2;   // → &a[3], advances 2×sizeof(int) bytes in memory

// Pointer TO an array (not to an element)
int (*ap)[3] = &a;   // type: int(*)[3]
(*ap)[0];            // → 1: deref first (→ array), then index
ap++;                // advances sizeof(int[3]) = 12 bytes!

*ap[0]   // → *(ap[0]) — [] beats * — DIFFERENT THING!

// Trap: INT_MIN has no positive counterpart!
INT_MAX =  2147483647  =  0x7FFFFFFF
INT_MIN = -2147483648  =  0x80000000
abs(INT_MIN)  →  UB!  (result doesn't fit in int)

int g_init   = 42;      // data segment
int g_uninit;           // BSS — zeroed automatically

void foo() {
    int local  = 1;     // stack
    int *p     = malloc(4); // p on stack, *p on heap
    static int s = 0;   // BSS (uninit static) or data (init static)
}

// Basic usage
int *p = malloc(sizeof(int) * 10);
if (!p) { /* always check! malloc returns NULL on failure */ }
memset(p, 0, sizeof(int) * 10);   // heap memory is NOT zeroed
free(p);
p = NULL;   // good habit — prevents use-after-free

// calloc — allocates AND zeroes
int *p2 = calloc(10, sizeof(int));

// realloc — resize existing allocation
p2 = realloc(p2, 20 * sizeof(int));  // may move the block!

// Safe pattern
void *safe_malloc(size_t n) {
    void *p = malloc(n);
    if (!p) { perror("malloc"); exit(EXIT_FAILURE); }
    return p;
}

void *memcpy (void *dst, const void *src, size_t n);  // UB if regions overlap
void *memmove(void *dst, const void *src, size_t n);  // safe if regions overlap

char buf[] = "hello world";

// Safe — regions don't overlap
memcpy(buf + 6, "there", 5);    // "hello there"

// UNSAFE with memcpy — overlapping regions
memcpy(buf + 1, buf, 5);        // UB! use memmove instead
memmove(buf + 1, buf, 5);       // correct

// Classic use: shifting array elements
memmove(&a[1], &a[0], n * sizeof(int));  // insert at front

// Declaration: pointer to function taking int, returning int
int (*fp)(int);

// Assign and call
int square(int x) { return x * x; }
fp = square;
int result = fp(5);    // → 25
int result = (*fp)(5); // same — both are valid

// typedef makes it readable
typedef int (*transform_fn)(int);
transform_fn fn = square;

// As function parameter (callback)
void apply(int *arr, int n, transform_fn fn) {
    for (int i = 0; i < n; i++) arr[i] = fn(arr[i]);
}

// Dispatch table — replaces switch/if-else chains
typedef void (*cmd_handler)(void);
cmd_handler dispatch[] = {
    [CMD_ARM]    = handle_arm,
    [CMD_DISARM] = handle_disarm,
    [CMD_TAKEOFF]= handle_takeoff,
};
dispatch[cmd]();  // O(1) dispatch, no branching

// static at file scope — internal linkage (invisible outside this .c file)
static int counter = 0;        // not accessible from other .c files
static void helper(void) {}    // private function

// static at function scope — persistent across calls
void count(void) {
    static int n = 0;   // initialised once, lives for program lifetime
    printf("%d\n", ++n);
}

// extern — declared here, defined in another .c file
extern int g_system_state;     // tells compiler "trust me, it exists"
extern void uart_init(void);

// inline — hint to compiler to expand inline (no function call overhead)
static inline uint32_t clamp(uint32_t v, uint32_t lo, uint32_t hi) {
    return v < lo ? lo : v > hi ? hi : v;
}
// static inline = inline + internal linkage — the correct pattern for headers

// volatile — prevents compiler caching, does NOT guarantee atomicity
volatile uint32_t *reg = (volatile uint32_t *)0x40011004;
while ((*reg & 0x01) == 0);   // compiler must re-read every iteration

// C11 atomics — guarantee both visibility AND atomicity
#include <stdatomic.h>
atomic_int shared = ATOMIC_VAR_INIT(0);
atomic_fetch_add(&shared, 1);                         // thread-safe increment
int v = atomic_load_explicit(&shared, memory_order_acquire);

// Classic ISR pattern — volatile is correct here (single read/write, no RMW)
volatile bool flag = false;

void ISR_handler(void) {
    flag = true;   // single store — atomic on most architectures
}

void main_loop(void) {
    while (!flag);   // volatile ensures re-read every time
    flag = false;
    process();
}

// Variables shared between ISR and main must be volatile
volatile uint32_t tick_count = 0;

void SysTick_Handler(void) {   // ISR — called by hardware
    tick_count++;               // write
}

void main(void) {
    while (1) {
        uint32_t t = tick_count;  // volatile — reads fresh value
        do_work(t);
    }
}

// ARM Cortex-M
uint32_t save = __get_PRIMASK();
__disable_irq();           // enter critical section
shared_var += 1;           // safe — interrupts disabled
__set_PRIMASK(save);       // restore (don't just re-enable blindly)

// Linux kernel equivalent
unsigned long flags;
spin_lock_irqsave(&lock, flags);
shared_var += 1;
spin_unlock_irqrestore(&lock, flags);

// Initialise watchdog with 1s timeout
watchdog_init(1000);  // 1000ms

// Main loop — must pet before timeout
while (1) {
    watchdog_kick();   // reset the counter ("I'm alive")
    do_work();
}

// If do_work() hangs → watchdog fires → CPU reset → system recovers

// Traditional include guard — portable, standard C
#ifndef MY_HEADER_H
#define MY_HEADER_H

// ... header content ...

#endif  // MY_HEADER_H

// #pragma once — simpler, supported by GCC/Clang/MSVC, not standard C
#pragma once

// ... header content ...

// Object-like macro
#define MAX_DRONES  16
#define PI          3.14159f

// Function-like macro — parenthesise everything!
#define MAX(a, b)   ((a) > (b) ? (a) : (b))  // safe
#define SQUARE(x)   ((x) * (x))               // safe
#define BAD(x)      x * x                     // unsafe: BAD(1+2) → 1+2*1+2 = 5!

// Stringification — # turns token into string literal
#define STRINGIFY(x)   #x
STRINGIFY(hello)  →  "hello"

// Token pasting — ## concatenates tokens
#define REG(n)   reg_##n
REG(status)  →  reg_status

// Conditional compilation
#ifdef DEBUG
    #define LOG(msg)  printf("[DBG] %s\n", msg)
#else
    #define LOG(msg)  ((void)0)   // compiles to nothing
#endif

// X-macro pattern — define list once, generate multiple things
#define STATES(X)  X(IDLE) X(ARMED) X(FLYING) X(FAULT)

typedef enum {
#define ENTRY(n) STATE_##n,
    STATES(ENTRY)
#undef ENTRY
} state_t;

static const char *state_names[] = {
#define ENTRY(n) [STATE_##n] = #n,
    STATES(ENTRY)
#undef ENTRY
};