Storage Classes,
Macros & Enums

#include <stdio.h>

/* ── Global variable (extern linkage by default) ── */
int globalScore = 100;

/* ── File-private global (static at file scope) ── */
static int filePrivate = 42;

void demonstrate() {
    /* auto: default storage class — re-created each call */
    auto int autoVar = 0;
    autoVar++;
    printf("  auto    autoVar   = %d  (always resets)\n", autoVar);

    /* static local: survives across calls — initialised once */
    static int callCount = 0;
    callCount++;
    printf("  static  callCount = %d  (keeps growing)\n", callCount);

    /* register: hint to use CPU register — acts like auto */
    register int regSum = 0;
    for (register int i = 1; i <= 5; i++) regSum += i;
    printf("  register regSum  = %d  (1+2+3+4+5)\n", regSum);

    /* extern: using the global variable from file scope */
    extern int globalScore;   /* re-declaration (optional here) */
    globalScore += 10;
    printf("  extern  globalScore = %d  (modified globally)\n",
           globalScore);

    printf("  static  filePrivate = %d  (file-only global)\n",
           filePrivate);
    printf("  ---\n");
}

int main() {
    printf("=== Storage Classes Demo ===\n\n");

    printf("Call 1:\n"); demonstrate();
    printf("Call 2:\n"); demonstrate();
    printf("Call 3:\n"); demonstrate();

    printf("\nFinal globalScore = %d\n", globalScore);
    return 0;
}

#include <stdio.h>

/* ─── 1. Object-like macros: simple constants ─── */
#define PI          3.14159265
#define MAX_STUDENTS 50
#define SCHOOL_NAME "Ananta Academy"
#define NEWLINE     '\n'

/* ─── 2. Function-like macros: parameterised ─── */
#define SQUARE(x)        ((x) * (x))
#define MAX(a, b)        ((a) > (b) ? (a) : (b))
#define MIN(a, b)        ((a) < (b) ? (a) : (b))
#define ABS(x)           ((x) < 0 ? -(x) : (x))
#define CLAMP(v, lo, hi) ((v) < (lo) ? (lo) : (v) > (hi) ? (hi) : (v))
#define SWAP(T, a, b)    do { T _t=(a); (a)=(b); (b)=_t; } while(0)

/* ─── 3. Stringification and token pasting ─── */
#define STRINGIFY(x)  #x
#define PASTE(a, b)   a##b

/* ─── 4. Conditional compilation ─── */
#define DEBUG 1
#ifdef DEBUG
  #define LOG(msg) printf("[DEBUG] %s\n", msg)
#else
  #define LOG(msg)   /* nothing in release build */
#endif

int main() {
    printf("=== Macros Demo ===\n\n");

    /* Object-like */
    printf("School      : %s\n",   SCHOOL_NAME);
    printf("Max students: %d\n",   MAX_STUDENTS);
    printf("PI          : %.8f\n\n", PI);

    /* Function-like macros */
    int a = 7, b = 12;
    printf("a=%d  b=%d\n", a, b);
    printf("SQUARE(a)   = %d\n",    SQUARE(a));
    printf("MAX(a,b)    = %d\n",    MAX(a, b));
    printf("MIN(a,b)    = %d\n",    MIN(a, b));
    printf("ABS(-99)    = %d\n",    ABS(-99));
    printf("CLAMP(150,0,100) = %d\n", CLAMP(150, 0, 100));

    /* SWAP using do-while(0) trick */
    printf("\nBefore SWAP: a=%d b=%d\n", a, b);
    SWAP(int, a, b);
    printf("After  SWAP: a=%d b=%d\n", a, b);

    /* Stringification */
    printf("\nSTRINGIFY(PI)   = \"%s\"\n", STRINGIFY(PI));
    printf("STRINGIFY(MAX_STUDENTS) = \"%s\"\n",
           STRINGIFY(MAX_STUDENTS));

    /* Token pasting: PASTE(var, 1) creates the token 'var1' */
    int PASTE(var, 1) = 999;
    printf("\nPASTE(var,1) creates var1 = %d\n", var1);

    /* Conditional LOG (active because DEBUG=1) */
    LOG("Main function reached end");
    return 0;
}

/* Traditional #ifndef guard */
#ifndef MYMATH_H
#define MYMATH_H

#define PI   3.14159265
#define TAU  (2 * PI)

static double circleArea(double r) { return PI * r * r; }
static double circumference(double r) { return TAU * r; }

#endif  /* MYMATH_H */

/* Modern alternative — one line, same effect: */
/* #pragma once  */

#include <stdio.h>

/* ─── Pattern 1: Default values (0, 1, 2, …) ─── */
typedef enum {
    MON, TUE, WED, THU, FRI, SAT, SUN
} Day;

const char *dayName(Day d) {
    const char *names[] = {
        "Monday","Tuesday","Wednesday","Thursday",
        "Friday","Saturday","Sunday"
    };
    return names[d];
}

/* ─── Pattern 2: Custom values ─── */
typedef enum {
    HTTP_OK        = 200,
    HTTP_CREATED   = 201,
    HTTP_NOT_FOUND = 404,
    HTTP_SERVER_ERR= 500
} HttpStatus;

const char *httpMsg(HttpStatus s) {
    switch (s) {
        case HTTP_OK:         return "200 OK";
        case HTTP_CREATED:    return "201 Created";
        case HTTP_NOT_FOUND:  return "404 Not Found";
        case HTTP_SERVER_ERR: return "500 Internal Server Error";
        default:             return "Unknown Status";
    }
}

/* ─── Pattern 3: Bit-flag enum (powers of 2) ─── */
typedef enum {
    PERM_NONE    = 0,        /* 0000 */
    PERM_READ    = 1 << 0,   /* 0001 */
    PERM_WRITE   = 1 << 1,   /* 0010 */
    PERM_EXECUTE = 1 << 2,   /* 0100 */
    PERM_ALL     = PERM_READ | PERM_WRITE | PERM_EXECUTE
} Permission;

void showPerms(int perms) {
    printf("  Permissions: %s%s%s\n",
           (perms & PERM_READ)    ? "READ "    : "",
           (perms & PERM_WRITE)   ? "WRITE "   : "",
           (perms & PERM_EXECUTE) ? "EXECUTE"  : "");
}

int main() {
    printf("=== Enums Demo ===\n\n");

    /* Pattern 1: Day of week */
    printf("--- Day enum (auto 0..6) ---\n");
    for (Day d = MON; d <= SUN; d++)
        printf("  %s = %d%s\n", dayName(d), d,
               (d == SAT || d == SUN) ? "  ← weekend" : "");

    /* Pattern 2: HTTP status codes */
    printf("\n--- HTTP status enum (custom values) ---\n");
    HttpStatus codes[] = { HTTP_OK, HTTP_CREATED,
                           HTTP_NOT_FOUND, HTTP_SERVER_ERR };
    for (int i = 0; i < 4; i++)
        printf("  codes[%d] = %s\n", i, httpMsg(codes[i]));

    /* Pattern 3: Bit-flag permissions */
    printf("\n--- Permission flags (bit-field enum) ---\n");
    int userPerm  = PERM_READ | PERM_WRITE;
    int guestPerm = PERM_READ;
    int rootPerm  = PERM_ALL;

    printf("User  (val=%d): ", userPerm);  showPerms(userPerm);
    printf("Guest (val=%d): ", guestPerm); showPerms(guestPerm);
    printf("Root  (val=%d): ", rootPerm);  showPerms(rootPerm);

    /* Revoke write from user */
    userPerm &= ~PERM_WRITE;
    printf("User after revoking WRITE (val=%d): ", userPerm);
    showPerms(userPerm);

    return 0;
}