Session 4 — Git Advanced + Code Quality: Instructor Print Guide

/* smell_uninit.c — Code smell: uninitialized variables
 *
 * All bugs below will be SILENTLY COMPILED with plain gcc.
 * Run: gcc smell_uninit.c -W -Wall -Wextra   to see warnings.
 * Run: clang-tidy --quiet -checks='*' smell_uninit.c --  for more.
 */

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

/* ---------------------------------------------------------------
 * Smell 1: plain local variable used before initialization.
 * GCC produces a warning only with -Wuninitialized (part of -Wall).
 * The value is whatever was on the stack — garbage.
 * --------------------------------------------------------------- */
void smell1_plain_local(void)
{
    int result;          /* declared but never assigned */
    printf("result = %d\n", result);   /* undefined behaviour */
}

/* ---------------------------------------------------------------
 * Smell 2: only some paths initialize the variable.
 * gcc -Wmaybe-uninitialized catches this; plain gcc misses it.
 * --------------------------------------------------------------- */
int smell2_partial_init(int x)
{
    int v;               /* not initialized unconditionally */
    if (x > 0)
        v = x * 2;
    /* if x <= 0, v is still garbage */
    return v;            /* may return garbage */
}

/* ---------------------------------------------------------------
 * Smell 3: switch without default — variable may stay unset.
 * --------------------------------------------------------------- */
const char *smell3_switch_no_default(int code)
{
    const char *msg;     /* uninitialized */
    switch (code)
    {
        case 0: msg = "zero";     break;
        case 1: msg = "one";      break;
        case 2: msg = "two";      break;
        /* no default: msg is uninitialized for any other code */
    }
    return msg;          /* UB if code not in {0,1,2} */
}

/* ---------------------------------------------------------------
 * Smell 4: pointer used before malloc / before NULL check.
 * Dereferencing without checking malloc return = crash or worse.
 * --------------------------------------------------------------- */
void smell4_ptr_no_null_check(int n)
{
    int *buf;
    buf = malloc(n * sizeof(int));
    /* BUG: no NULL check — if malloc fails, next line crashes */
    buf[0] = 42;
    free(buf);
}

/* ---------------------------------------------------------------
 * Smell 5: pointer declared, never assigned, then freed.
 * This is undefined behaviour — the free() call is on garbage.
 * --------------------------------------------------------------- */
void smell5_free_uninit_ptr(void)
{
    char *p;             /* declared but never assigned */
    /* ... some code that "forgets" to assign p ... */
    free(p);             /* UB: freeing a garbage pointer */
}

/* ---------------------------------------------------------------
 * Smell 6: struct fields silently left at 0/garbage.
 * Using = {0} for zero-init is not always enough (e.g. pointers
 * on exotic platforms), but missing = {0} is clearly wrong.
 * --------------------------------------------------------------- */
typedef struct
{
    int    width;
    int    height;
    char  *label;
    double ratio;
} Box;

void smell6_partial_struct_init(void)
{
    Box b;               /* all fields uninitialized */
    b.width = 10;        /* only width set */
    /* height, label, ratio are garbage */
    printf("box: %d x %d  label=%s  ratio=%.2f\n",
           b.width, b.height, b.label, b.ratio);
}

/* ---------------------------------------------------------------
 * Smell 7: loop variable reused without reset between loops.
 * The second loop starts from wherever i ended — logic bug.
 * --------------------------------------------------------------- */
void smell7_loop_var_reuse(void)
{
    int i;
    int a[5] = {1, 2, 3, 4, 5};
    int b[3] = {10, 20, 30};

    for (i = 0; i < 5; i++)
        printf("a[%d]=%d ", i, a[i]);
    printf("\n");

    /* BUG: i still equals 5 from the previous loop.
     * The second loop never executes! */
    for (; i < 3; i++)
        printf("b[%d]=%d ", i, b[i]);
    printf("\n");
}

/* ---------------------------------------------------------------
 * Smell 8: VLA declared, but size comes from uninitialized var.
 * This is particularly dangerous — any array size is possible.
 * --------------------------------------------------------------- */
void smell8_vla_garbage_size(void)
{
    int n;               /* uninitialized — could be negative! */
    /* The line below may crash, allocate billions of bytes,
     * or silently corrupt the stack depending on what n holds. */
    int arr[n];          /* VLA with garbage size */
    arr[0] = 1;
}

int main(void)
{
    smell1_plain_local();
    printf("partial_init(5)  = %d\n", smell2_partial_init(5));
    printf("partial_init(-1) = %d\n", smell2_partial_init(-1)); /* UB */
    printf("switch msg       = %s\n", smell3_switch_no_default(0));
    printf("switch bad code  = %s\n", smell3_switch_no_default(99)); /* UB */
    smell4_ptr_no_null_check(10);
    smell6_partial_struct_init();
    smell7_loop_var_reuse();
    /* smell5 and smell8 would crash — left commented out */
    return 0;
}

/* smell_layout.c — Code smell: bad formatting and layout
 *
 * Issues demonstrated:
 *  - Extremely long lines (200+ characters)
 *  - Mixed indentation (tabs vs spaces, 2 vs 4 vs 8 spaces)
 *  - Mixed brace placement styles in the same file
 *  - Multiple statements crammed on one line
 *  - Operators with no spaces, or inconsistent spacing
 *  - Magic numbers scattered everywhere
 *  - Return type on a separate line from function name (old K&R style)
 */

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

/* ---------------------------------------------------------------
 * Smell 1: extremely long lines — no one can read this without
 * horizontal scrolling.  The 80/100/120 column limit exists for
 * a reason.
 * --------------------------------------------------------------- */
void process_image(unsigned char input_matrix[1024][1024], unsigned char output_matrix[1024][1024], int width, int height, int threshold, int mode) { for (int row = 0; row < height; row++) { for (int col = 0; col < width; col++) { if (mode == 0) { output_matrix[row][col] = (input_matrix[row][col] > threshold) ? 255 : 0; } else if (mode == 1) { output_matrix[row][col] = (unsigned char)(0.299 * input_matrix[row][col] + 0.587 * input_matrix[row][col] + 0.114 * input_matrix[row][col]); } else { output_matrix[row][col] = input_matrix[row][col]; } } } }

/* ---------------------------------------------------------------
 * Smell 2: mixed brace style — Allman for one function, K&R for
 * the next, Egyptian for a third.  Pick one and stick with it.
 * --------------------------------------------------------------- */

/* Allman style */
int compute_sum(int *array, int size)
{
    int total = 0;
    for (int i = 0; i < size; i++)
    {
        total += array[i];
    }
    return total;
}

/* K&R style — inconsistent with the function above */
int compute_max(int *array, int size) {
    int m = array[0];
    for (int i = 1; i < size; i++) {
        if (array[i] > m) { m = array[i]; }
    }
    return m;
}

/* No braces at all on multi-line if/else — easy to misread */
int compute_min(int *array, int size)
{
    int m = array[0];
    for (int i = 1; i < size; i++)
        if (array[i] < m)
            m = array[i];
    return m;
}

/* ---------------------------------------------------------------
 * Smell 3: inconsistent indentation — 2 spaces, then 4, then tabs.
 * Many editors will show this as completely different widths.
 * --------------------------------------------------------------- */
void print_matrix(int rows, int cols, double matrix[rows][cols])
{
  for (int i = 0; i < rows; i++) {    /* 2-space indent */
      for (int j = 0; j < cols; j++) {  /* 4-space indent */
	      printf("%6.2f ", matrix[i][j]);  /* tab indent */
      }
    printf("\n");   /* back to 2-space */
  }
}

/* ---------------------------------------------------------------
 * Smell 4: operators with no spaces — looks like a formula from
 * a 1970s Fortran book.
 * --------------------------------------------------------------- */
double quadratic(double a,double b,double c,double x){return a*x*x+b*x+c;}

double discriminant(double a,double b,double c){
double d=b*b-4*a*c;
return d;
}

/* ---------------------------------------------------------------
 * Smell 5: multiple statements on one line everywhere.
 * This makes it impossible to set breakpoints on individual steps
 * and hides the logic flow completely.
 * --------------------------------------------------------------- */
void compress_array(int *src, int *dst, int n, int factor)
{
    int i=0,j=0,sum=0,count=0;
    while(i<n){sum+=src[i];count++;i++;if(count==factor){dst[j]=sum/factor;j++;sum=0;count=0;}}
    if(count>0){dst[j]=sum/count;}
}

/* ---------------------------------------------------------------
 * Smell 6: old K&R-style function declaration (no parameter types
 * in the signature line — types come separately).  This predates
 * ANSI C and gives the compiler zero information to check calls.
 * --------------------------------------------------------------- */
int old_style_add(a, b)
int a;
int b;
{
    return a + b;
}

/* ---------------------------------------------------------------
 * Smell 7: misaligned closing braces and random blank lines that
 * break the visual grouping of code blocks.
 * --------------------------------------------------------------- */
void state_machine(int input)
{
    static int state = 0;

    if (state == 0)
    {
        if (input == 1) { state = 1;
        printf("0→1\n"); }
        else { printf("stay 0\n");
            }
    } else if (state == 1) {
            if (input == 0) {
        state = 0; printf("1→0\n"); }

    else { state = 2; printf("1→2\n");
    }
    }
    else
    {
    printf("state 2 — reset\n");
    state=0;
            }
}

/* ---------------------------------------------------------------
 * Smell 8: magic numbers with no explanation.
 * What is 0.2126? 0.7152? 0.0722? (they are luma coefficients)
 * What is 255? What is 16, 235? (TV range vs full range)
 * --------------------------------------------------------------- */
unsigned char to_luma(unsigned char r, unsigned char g, unsigned char b)
{
    double luma = 0.2126 * r + 0.7152 * g + 0.0722 * b;
    if (luma < 16)  luma = 16;
    if (luma > 235) luma = 235;
    return (unsigned char)luma;
}

int main(void)
{
    int arr[] = {5, 3, 8, 1, 9, 2};
    int n = 6;
    printf("sum=%d max=%d min=%d\n",
           compute_sum(arr, n), compute_max(arr, n), compute_min(arr, n));
    printf("quad(1,0,-1,3)=%.1f\n", quadratic(1, 0, -1, 3));
    printf("luma(200,100,50)=%d\n", to_luma(200, 100, 50));
    return 0;
}

/* smell_naming.c — Code smell: bad, inconsistent, and cryptic naming
 *
 * Issues demonstrated:
 *  - Single-letter names outside of trivial loop indices
 *  - Inconsistent casing: camelCase vs snake_case vs ALLCAPS for non-macros
 *  - Generic / meaningless names: tmp, temp, data, val, res, ret, buf, ptr
 *  - Over-abbreviated names that require context to decode
 *  - Function names that do not describe what the function does
 *  - Boolean variables named as verbs with confusing polarity (isNotDone)
 */

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

/* ---------------------------------------------------------------
 * Smell 1: single-letter names for non-trivial roles.
 * What does 'n' hold? What is 'r' the result of? 'f'? 'a', 'b'?
 * --------------------------------------------------------------- */
double f(double a, double b, double n)
{
    double r = 0;
    double x = a;
    double h = (b - a) / n;   /* h is OK here — well-known in math */
    while (x < b)
    {
        r += (x * x + 2 * x + 1) * h;  /* what polynomial is this? */
        x += h;
    }
    return r;
}

/* ---------------------------------------------------------------
 * Smell 2: inconsistent naming conventions in the same file.
 * camelCase function next to snake_case function next to ALLCAPS.
 * --------------------------------------------------------------- */
int computeAverage(int *array, int size)   /* camelCase */
{
    int total = 0;
    for (int i = 0; i < size; i++) total += array[i];
    return total / size;
}

int find_median(int *array, int size)      /* snake_case */
{
    /* (assumes sorted) */
    return array[size / 2];
}

int FINDMAX(int *T, int N)                 /* ALLCAPS — not a macro! */
{
    int M = T[0];
    for (int I = 1; I < N; I++)
        if (T[I] > M) M = T[I];
    return M;
}

/* ---------------------------------------------------------------
 * Smell 3: generic meaningless names — every variable is tmp/data/res.
 * Reading this function requires re-deriving what each variable means.
 * --------------------------------------------------------------- */
int *process(int *data, int tmp, int res)
{
    int *ret = malloc(tmp * sizeof(int));
    if (ret == NULL) return NULL;

    int val = 0;
    for (int i = 0; i < tmp; i++)
    {
        val = data[i] * res;
        ret[i] = val;
    }
    return ret;
}

/* ---------------------------------------------------------------
 * Smell 4: over-abbreviated names.
 * nb_elt? lng? buf_sz? blk_cnt? Abbreviated to the point of cryptic.
 * --------------------------------------------------------------- */
int cpy_blk(char *dst, const char *src, int nb_elt, int blk_sz, int buf_sz)
{
    int lng    = 0;
    int blk_cnt = 0;

    while (lng < nb_elt && blk_cnt * blk_sz < buf_sz)
    {
        memcpy(dst + blk_cnt * blk_sz, src + blk_cnt * blk_sz, blk_sz);
        lng    += blk_sz;
        blk_cnt++;
    }
    return blk_cnt;
}

/* ---------------------------------------------------------------
 * Smell 5: boolean variable with negative/confusing polarity.
 * Double negatives in conditions are a reading trap.
 * --------------------------------------------------------------- */
void pump_events(int max_iter)
{
    int isNotDone  = 1;    /* confusing: we need NOT NOT done to continue */
    int noError    = 1;    /* same issue */
    int iter       = 0;

    while (isNotDone && noError)
    {
        if (!isNotDone) break;  /* dead code because of the while condition */
        iter++;
        if (iter >= max_iter) isNotDone = 0;  /* double-negative assignment */
    }
}

/* ---------------------------------------------------------------
 * Smell 6: function names that describe HOW, not WHAT.
 * "doLoop", "doStuff", "helper", "util", "run" give zero information.
 * --------------------------------------------------------------- */
void doLoop(int *arr, int n)   /* what loop? for what purpose? */
{
    for (int i = 0; i < n; i++)
        arr[i] *= 2;
}

int helper(int a, int b)       /* helper for what? */
{
    return (a > b) ? a : b;
}

void doStuff(void)             /* the worst possible name */
{
    printf("doing stuff\n");
}

/* ---------------------------------------------------------------
 * Smell 7: shadowing — local variable has the same name as
 * a global/outer variable.  Which 'count' is being modified?
 * --------------------------------------------------------------- */
int count = 0;   /* global */

void increment(void)
{
    int count = 0;     /* shadows the global — bug hiding in plain sight */
    count++;           /* only increments the local copy */
    printf("local count = %d, global count = %d\n", count, count);
    /* the two 'count' in printf both refer to the local! */
}

/* ---------------------------------------------------------------
 * Smell 8: type-Hungarian notation applied inconsistently.
 * Some vars have a prefix (pBuf, iLen), others don't — so the
 * prefix adds noise without consistency benefits.
 * --------------------------------------------------------------- */
void Hungarian(char *pBuf, int iLen, int offset)
{
    int i;      /* no prefix */
    char c;     /* no prefix */
    int nBytes = iLen - offset;   /* partial prefix */

    for (i = 0; i < nBytes; i++)
    {
        c = pBuf[i + offset];
        printf("%c", c);
    }
    printf("\n");
}

int main(void)
{
    int arr[] = {4, 1, 7, 2, 9, 3, 8};
    int n     = 7;

    printf("f(0,1,1000) = %.4f\n", f(0, 1, 1000));
    printf("avg   = %d\n", computeAverage(arr, n));
    printf("max   = %d\n", FINDMAX(arr, n));

    int src_data[] = {1, 2, 3, 4, 5};
    int *out = process(src_data, 5, 3);
    if (out) { free(out); }

    increment();
    return 0;
}

/* smell_includes.c — Code smell: #include directives not at the top
 *
 * The C standard requires declarations to be in scope before use,
 * but nothing technically forbids putting #include in the middle of
 * a file.  However, this is a severe readability and maintenance issue:
 *  - Readers don't know which headers are available where.
 *  - Conditional or late includes can cause subtle ordering bugs.
 *  - Static checkers, IDEs, and code formatters assume includes come first.
 *
 * All "smells" below are deliberately placed in the wrong location.
 */

#include <stdio.h>   /* OK — this is where includes should be */

/* A global constant — fine so far */
#define BUFFER_SIZE 256
#define PI 3.14159265358979

/* ---------------------------------------------------------------
 * Smell 1: #include buried after some declarations.
 * The programmer added stdlib.h "when they needed malloc" rather
 * than gathering all includes at the top.
 * --------------------------------------------------------------- */
static int g_counter = 0;

#include <stdlib.h>  /* BAD: should be at the top with stdio.h */

void increment_counter(void)
{
    g_counter++;
}

int get_counter(void)
{
    return g_counter;
}

/* ---------------------------------------------------------------
 * Smell 2: #include after function definitions.
 * string.h is only needed further down but is included here,
 * between two function groups — confusing for anyone reading top-down.
 * --------------------------------------------------------------- */
double circle_area(double radius)
{
    return PI * radius * radius;
}

double sphere_volume(double radius)
{
    return (4.0 / 3.0) * PI * radius * radius * radius;
}

#include <string.h>  /* BAD: mid-file, after geometry functions */

char *safe_duplicate(const char *src)
{
    if (src == NULL) return NULL;
    char *copy = malloc(strlen(src) + 1);
    if (copy == NULL) return NULL;
    strcpy(copy, src);
    return copy;
}

/* ---------------------------------------------------------------
 * Smell 3: #define used before the matching #include that would
 * normally provide the type.  Here the programmer added the
 * #include only when the compiler complained, inserting it at the
 * point of use rather than the top of the file.
 * --------------------------------------------------------------- */
#define MAX_FILES 16

typedef struct
{
    int   fd;
    char  name[BUFFER_SIZE];
    int   is_open;
} FileEntry;

#include <errno.h>   /* BAD: should be at the top */

int open_file_entry(FileEntry *entry, const char *name)
{
    if (entry == NULL || name == NULL)
    {
        errno = EINVAL;
        return -1;
    }
    strncpy(entry->name, name, BUFFER_SIZE - 1);
    entry->name[BUFFER_SIZE - 1] = '\0';
    entry->is_open = 0;
    entry->fd      = -1;
    return 0;
}

/* ---------------------------------------------------------------
 * Smell 4: conditional #include inside a function body.
 * This compiles on some platforms/compilers but is never correct
 * style and is explicitly undefined behaviour in C11+.
 * --------------------------------------------------------------- */
void print_platform_info(void)
{
#include <stdint.h>   /* VERY BAD: #include inside a function */
    uint32_t magic = 0xDEADBEEF;
    printf("magic = 0x%08X\n", magic);
    printf("sizeof(uint32_t) = %zu\n", sizeof(uint32_t));
}

/* ---------------------------------------------------------------
 * Smell 5: recursive / circular include chain simulated inline.
 * Including a header that pulls in another header that could pull
 * back in the current file — avoided here by guards, but the
 * smell is placing the #include so late that guards are not
 * checked until execution is logically "inside" the file.
 * --------------------------------------------------------------- */
int compute_hash(const char *s)
{
    unsigned int h = 5381;
    int c;
    while ((c = *s++) != '\0')
        h = ((h << 5) + h) + (unsigned int)c;  /* djb2 */
    return (int)(h % 65521);
}

#include <math.h>    /* BAD: used only in the last function, added late */

double normalize(double value, double min_val, double max_val)
{
    if (fabs(max_val - min_val) < 1e-9)
        return 0.0;
    return (value - min_val) / (max_val - min_val);
}

int main(void)
{
    increment_counter();
    increment_counter();
    printf("counter = %d\n", get_counter());

    printf("circle area r=3: %.4f\n", circle_area(3.0));

    char *dup = safe_duplicate("hello world");
    printf("duplicate: %s\n", dup);
    free(dup);

    FileEntry fe;
    open_file_entry(&fe, "test.txt");
    printf("file entry name: %s\n", fe.name);

    print_platform_info();

    printf("hash(\"hello\") = %d\n", compute_hash("hello"));
    printf("normalize(5, 0, 10) = %.2f\n", normalize(5.0, 0.0, 10.0));

    return 0;
}

/* smell_combined.c — Realistic "student project" accumulating ALL smells
 *
 * This file simulates a real student submission that was written quickly,
 * never reviewed, and never run through any quality tool.
 *
 * Smells present (for instructor annotation on projector):
 *  [U] Uninitialized variable
 *  [L] Layout / formatting issue
 *  [N] Naming issue
 *  [I] Include not at top
 *  [D] DRY violation (duplicated logic)
 *  [M] Memory issue (leak / overflow / UB)
 *
 * Compile with:
 *    gcc smell_combined.c -W -Wall -Wextra -o smell_combined
 * Then:
 *    clang-tidy --quiet -checks='*' smell_combined.c --
 */

#include <stdio.h>

#define TMAX 50
#define NMAX 20

/* [N] Inconsistent naming: camelCase next to snake_case */
/* [L] No blank lines to separate logical sections         */
typedef struct{int x;int y;char nom[32];int valeur;}Point;   /* [L] cramped */
typedef struct{Point pts[NMAX];int nb;}PointSet;

#include <string.h>  /* [I] mid-file include */

/* [N] Single-letter parameter names with no obvious meaning */
/* [L] One-liner that should be expanded for readability     */
double dist(Point a,Point b){return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y);}

/* [D] Duplicated logic: almost identical to dist() above */
double Distance(Point p1,Point p2){    /* [N] inconsistent casing */
double dx=p1.x-p2.x;double dy=p1.y-p2.y;   /* [L] two stmts on one line */
return dx*dx+dy*dy;}

/* [N][L] Meaningless name, everything on one line */
int f(PointSet*s,int v){int r=0;for(int i=0;i<s->nb;i++)if(s->pts[i].valeur==v)r++;return r;}

#include <stdlib.h>  /* [I] mid-file include */

/* [N] "process" tells us nothing; [U] res uninitialized on some paths */
int process(PointSet *s, int mode)
{
    int res;                    /* [U] uninitialized */
    if(mode==0){                /* [L] no space before { */
        int sum=0;
        for(int i=0;i<s->nb;i++)sum+=s->pts[i].valeur;
        res=sum;
    }
    else if(mode==1){
        int mx=s->pts[0].valeur;   /* [U] UB if s->nb == 0 */
        for(int i=1;i<s->nb;i++)if(s->pts[i].valeur>mx)mx=s->pts[i].valeur;
        res=mx;
    }
    /* [U] if mode is anything else, res is still garbage */
    return res;
}

/* [N] "do_truc" is meaningless French slang */
/* [L] Mix of 2-space and 4-space indentation */
void do_truc(PointSet *s, char *Nom, int V)  /* [N] Nom is camelCase, V is ALLCAPS */
{
  Point p;           /* [L] 2-space indent inside function */
  p.x=rand()%100;p.y=rand()%100;  /* [L] two stmts on one line; [U] no srand */
    strcpy(p.nom,Nom);  /* [L] 4-space indent now — inconsistent; [M] no bounds check */
  p.valeur=V;
  if(s->nb<NMAX)      /* [L] no space after if */
  {
    s->pts[s->nb]=p;
      s->nb++;        /* [L] 6-space indent — different again */
  }
}

/* [D] Duplicated printing logic — nearly identical to print_set below */
void AfficherPoints(PointSet *s)   /* [N] French + camelCase */
{
    for(int i=0;i<s->nb;i++)
        printf("(%d,%d) %s val=%d\n",s->pts[i].x,s->pts[i].y,s->pts[i].nom,s->pts[i].valeur);
}

/* [D] Almost the same function with a slightly different format string */
void print_set(PointSet *s)
{
    for(int i=0;i<s->nb;i++)
        printf("[%d,%d] '%s' v=%d\n",s->pts[i].x,s->pts[i].y,s->pts[i].nom,s->pts[i].valeur);
}

#include <math.h>   /* [I] late include — only used in find_closest */

/* [N] Return type on its own line (old K&R style) */
/* [M] Returns pointer to first match — but what if no match? returns NULL  */
/* (actually: uninitialized 'closest' if s->nb==0) */
Point *
find_closest(PointSet *s, Point ref)  /* [L] function name split across lines */
{
    Point *closest;    /* [U] uninitialized pointer — UB if nb==0 */
    double dMin=1e18;
    for(int i=0;i<s->nb;i++){
        double d=sqrt(dist(s->pts[i],ref));  /* [D] dist() already squared — sqrt is wrong */
        if(d<dMin){dMin=d;closest=&s->pts[i];}
    }
    return closest;   /* [U] if nb==0, closest is garbage */
}

/* [M] Memory leak: buf is never freed */
/* [N] "tmp_str" then "buffer" then "buf" — three names for the same concept */
char *BuildLabel(Point *p, int id)   /* [N] camelCase again */
{
    char tmp_str[64];
    sprintf(tmp_str,"%s#%d@(%d,%d)",p->nom,id,p->x,p->y);  /* [M] no bounds check */
    char *buf=malloc(strlen(tmp_str)+1);
    if(buf==NULL)return NULL;
    strcpy(buf,tmp_str);
    return buf;
    /* [M] caller must free buf — but there's no documentation of this */
}

int main()   /* [N] should be main(void) */
{
    PointSet S;      /* [N] single uppercase letter — means nothing */
    S.nb=0;

    do_truc(&S,"Alice",10);
    do_truc(&S,"Bob",20);
    do_truc(&S,"Charlie",10);
    do_truc(&S,"Dave",30);

    printf("--- AfficherPoints ---\n");
    AfficherPoints(&S);
    printf("--- print_set ---\n");
    print_set(&S);

    printf("mode 0 (sum): %d\n",process(&S,0));
    printf("mode 1 (max): %d\n",process(&S,1));
    printf("mode 2 (???): %d\n",process(&S,2));  /* [U] garbage returned */

    printf("count valeur==10: %d\n",f(&S,10));

    Point ref; ref.x=50; ref.y=50; ref.valeur=0; strcpy(ref.nom,"ref"); /* [L] cramped */
    Point *cl=find_closest(&S,ref);
    if(cl!=NULL)
        printf("closest to (50,50): %s\n",cl->nom);

    char *lbl=BuildLabel(&S.pts[0],1);
    if(lbl){
        printf("label: %s\n",lbl);
        /* [M] forgot to free(lbl) — memory leak */
    }

    return 0;
}

# .gitlab-ci.yml — Incremental C project pipeline
#
# Pipeline topology (DAG — not linear stages):
#
#   format ──┐
#             ├── lint:tidy ──┐
#             └── lint:check ─┤
#                              └── build:compile ──┐
#                                                   └── build:link ──┐
#                                                                     ├── test:unit
#                                                                     └── test:asan
#                                                                           └── report:coverage
#
# Key features demonstrated:
#  - Explicit Docker image per job (reproducible environment)
#  - `needs:` for DAG-style execution (jobs run as soon as deps are met)
#  - `rules:` for conditional execution (skip format check on main branch)
#  - `cache:` with a lockfile key (avoid re-installing deps)
#  - `artifacts:` passed between jobs (object files from compile → link)
#  - `allow_failure: true` on lint jobs (warnings don't block the build)
#  - `coverage:` regex to parse lcov output for GitLab's coverage badge

# ── Global defaults ──────────────────────────────────────────────────────────
default:
    image: gcc:13   # default image; individual jobs can override
    before_script:
        - apt-get update -qq
        - apt-get install -y -qq make clang-format clang-tidy cppcheck
              lcov gcovr libcheck-dev 2>/dev/null

# ── Stage declaration (order matters for the pipeline graph) ─────────────────
stages:
    - format
    - lint
    - build
    - test
    - report

# ── Variables ─────────────────────────────────────────────────────────────────
variables:
    CC:      gcc
    CFLAGS:  "-W -Wall -Wextra -Iinclude -MMD"
    LDFLAGS: "-lm"
    BUILD:   build
    SRC_DIR: src
    TEST_DIR: tests

# ── Stage: format ─────────────────────────────────────────────────────────────
# Check that all C sources are correctly formatted with clang-format.
# This is the first gate: if formatting is wrong the rest of the pipeline
# is still triggered (allow_failure: true) but the job is red.
format:check:
    stage: format
    image: silkeh/clang:17   # use a dedicated clang image for format tools
    before_script: []        # skip the global before_script (nothing to install)
    script:
        - echo "=== Checking code formatting ==="
        - >
            clang-format --dry-run --Werror
            $(find $SRC_DIR $TEST_DIR include -name '*.c' -o -name '*.h' 2>/dev/null)
    allow_failure: true      # format errors are warnings, not blockers
    rules:
        # Run on every push except the main branch (main is assumed to be clean)
        - if: $CI_COMMIT_BRANCH != "main"
        - if: $CI_PIPELINE_SOURCE == "merge_request_event"

# ── Stage: lint ───────────────────────────────────────────────────────────────
# Two lint jobs run in PARALLEL (both depend only on format:check via needs).
# They always run even if format:check failed (needs with optional: true).

lint:tidy:
    stage: lint
    image: silkeh/clang:17
    before_script: []
    needs:
        - job: format:check
          optional: true     # run even if format:check did not run
    script:
        - echo "=== Running clang-tidy ==="
        - >
            clang-tidy --quiet
            $(find $SRC_DIR -name '*.c')
            -- $CFLAGS
    allow_failure: true      # tidy warnings don't block the build

lint:cppcheck:
    stage: lint
    image: neszt/cppcheck-docker   # dedicated cppcheck image
    before_script: []
    needs:
        - job: format:check
          optional: true
    script:
        - echo "=== Running cppcheck ==="
        - >
            cppcheck --enable=warning,style,portability
            --error-exitcode=1
            --suppress=missingIncludeSystem
            -I include
            $SRC_DIR/*.c
    allow_failure: true

# ── Stage: build ──────────────────────────────────────────────────────────────
# Compilation is split into two jobs:
#   1. build:compile  — compiles every .c to .o (parallel if extended)
#   2. build:link     — links all .o files into the final executable
#
# The object files are passed from compile → link via artifacts.

build:compile:
    stage: build
    needs:
        - job: lint:tidy
          optional: true
        - job: lint:cppcheck
          optional: true
    cache:
        key:
            files:
                - $SRC_DIR/*.c
                - include/*.h
        paths:
            - $BUILD/
    script:
        - echo "=== Compiling source files ==="
        - mkdir -p $BUILD
        - >
            for src in $SRC_DIR/*.c; do
                obj="$BUILD/$(basename ${src%.c}.o)";
                echo "  CC $src → $obj";
                $CC $CFLAGS -c "$src" -o "$obj";
            done
    artifacts:
        paths:
            - $BUILD/*.o
            - $BUILD/*.d    # dependency files for incremental rebuilds
        expire_in: 1 hour

build:link:
    stage: build
    needs:
        - build:compile    # wait for .o files
    script:
        - echo "=== Linking ==="
        - mkdir -p $BUILD
        - $CC $BUILD/*.o $LDFLAGS -o $BUILD/project
        - echo "=== Binary size ==="
        - size $BUILD/project
    artifacts:
        paths:
            - $BUILD/project
        expire_in: 1 day

# ── Stage: test ───────────────────────────────────────────────────────────────
# Two test jobs run in PARALLEL once the binary is ready:
#   1. test:unit   — runs the libcheck test suite
#   2. test:asan   — recompiles with AddressSanitizer and runs tests

test:unit:
    stage: test
    needs:
        - build:link
    script:
        - echo "=== Compiling unit tests ==="
        - >
            $CC $CFLAGS --coverage $SRC_DIR/*.c $TEST_DIR/*.c
            -o $BUILD/project_tests -lcheck $LDFLAGS
        - echo "=== Running unit tests ==="
        - ./$BUILD/project_tests
    artifacts:
        paths:
            - $BUILD/*.gcno
            - $BUILD/*.gcda
        expire_in: 1 hour
    coverage: '/^lines:\s+(\d+\.\d+)%/'

test:asan:
    stage: test
    image: silkeh/clang:17
    before_script: []
    needs:
        - build:link        # only needs the link stage to know the build succeeded
    script:
        - echo "=== Recompiling with AddressSanitizer ==="
        - >
            clang -W -Wall -Wextra -g -fsanitize=address,undefined
            -Iinclude
            $SRC_DIR/*.c $TEST_DIR/*.c
            -o $BUILD/project_asan -lcheck $LDFLAGS
        - echo "=== Running ASan ==="
        - ASAN_OPTIONS=halt_on_error=1 ./$BUILD/project_asan
    allow_failure: false    # ASan errors ARE blockers

# ── Stage: report ─────────────────────────────────────────────────────────────
# Generate an HTML coverage report from the gcov data produced by test:unit.
# This job only runs on the main branch or on MRs.

report:coverage:
    stage: report
    needs:
        - test:unit        # need the .gcda files
    rules:
        - if: $CI_COMMIT_BRANCH == "main"
        - if: $CI_PIPELINE_SOURCE == "merge_request_event"
    script:
        - echo "=== Generating coverage report ==="
        - mkdir -p report
        - gcov -f -b $BUILD/*.gcda
        - lcov --directory $BUILD --base-directory . -c -o report/cov.info
        - lcov --remove report/cov.info '/usr/*' '*/tests/*' -o report/cov_filtered.info
        - genhtml report/cov_filtered.info -o report/html
        - echo "=== Coverage summary ==="
        - lcov --summary report/cov_filtered.info
    artifacts:
        paths:
            - report/html/
        expire_in: 1 week
        reports:
            coverage_report:
                coverage_format: cobertura
                path: report/cobertura.xml
    coverage: '/^\s*lines\.*:\s*(\d+\.\d+)%/'