> GNU MAKE REFERENCE MANUAL

# Make cerca in questo ordine:
1. GNUmakefile
2. makefile
3. Makefile          # ← convenzione più usata

target: dipendenza1 dipendenza2 ...
	comando1
	comando2

# IMPORTANTE: i comandi DEVONO essere indentati con TAB, non spazi!

# Esempio concreto:
prog: main.o utils.o
	gcc main.o utils.o -o prog

main.o: main.c main.h
	gcc -c main.c

utils.o: utils.c utils.h
	gcc -c utils.c

# Più target con la stessa regola
file1.o file2.o: common.h

# Equivale a:
file1.o: common.h
file2.o: common.h

# Dipendenze aggiuntive (si accumulano)
main.o: main.c
main.o: config.h utils.h
# main.o dipende da main.c, config.h E utils.h

# I prerequisiti dopo | non influenzano il timestamp
# Usati tipicamente per creare directory
build/prog.o: prog.c | build
	gcc -c prog.c -o build/prog.o

build:
	mkdir -p build
# La directory viene creata se non esiste,
# ma modificarla non forza la ricompilazione

.PHONY: all clean install uninstall rebuild test

all: prog

clean:
	rm -f *.o prog

install: prog
	install -m 755 prog /usr/local/bin/

uninstall:
	rm -f /usr/local/bin/prog

rebuild: clean all

test: prog
	./prog --test

CC      = gcc                 # compilatore C
CXX     = g++                 # compilatore C++
CFLAGS  = -Wall -Wextra -g    # flag compilazione C
CXXFLAGS= -Wall -Wextra -g    # flag compilazione C++
LDFLAGS = -L/usr/local/lib    # flag linker (percorsi)
LDLIBS  = -lm -lpthread      # librerie da linkare
CPPFLAGS= -I./include -DDEBUG # flag preprocessore
AR      = ar                  # archiviatore
ARFLAGS = rcs                 # flag per ar

TARGET  = prog
SRC     = main.c utils.c io.c
OBJ     = $(SRC:.c=.o)        # main.o utils.o io.o

$(TARGET): $(OBJ)
	$(CC) $(LDFLAGS) $^ -o $@ $(LDLIBS)

# Senza variabili automatiche (ripetitivo)
prog: main.o utils.o
	gcc main.o utils.o -o prog

# Con variabili automatiche (generico e manutenibile)
prog: main.o utils.o
	$(CC) $(LDFLAGS) $^ -o $@ $(LDLIBS)

# $@ = prog, $^ = main.o utils.o

# Pattern rule con $< e $@
%.o: %.c
	$(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@
# $< = il file .c corrispondente, $@ = il file .o target

# Recursive (=) — espansione ritardata
A = $(B)
B = hello
# $(A) vale "hello" — B viene espanso quando si usa A

# Simple (:=) — espansione immediata
A := $(B)
B := hello
# $(A) vale "" — B era vuoto quando A è stato assegnato

# Conditional (?=)
CC ?= gcc
# CC = gcc solo se non già definito (es. da ambiente o command line)

# Append (+=)
CFLAGS  = -Wall
CFLAGS += -Wextra
CFLAGS += -g
# CFLAGS = "-Wall -Wextra -g"

# Shell (!=)
GIT_HASH != git rev-parse --short HEAD
# Equivalente a: GIT_HASH := $(shell git rev-parse --short HEAD)

# Senza override: "make CFLAGS=-O2" sovrascrive il Makefile
CFLAGS = -Wall -g

# Con override: -g viene SEMPRE aggiunto, anche con override da CLI
override CFLAGS += -g

# Esportare variabili ai sub-make
export CC CFLAGS LDFLAGS

# Esportare tutto
export

# Non esportare una variabile specifica
unexport SECRET_KEY

# Variabili che valgono solo per un target (e le sue dipendenze)
debug: CFLAGS += -DDEBUG -O0
debug: prog

release: CFLAGS += -O2 -DNDEBUG
release: prog

# Ora: "make debug" compila con -DDEBUG -O0
#      "make release" compila con -O2 -DNDEBUG

# Regola generica: qualsiasi .c → .o
%.o: %.c
	$(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@

# Regola generica: qualsiasi .cpp → .o
%.o: %.cpp
	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $< -o $@

# Con directory di output
build/%.o: src/%.c | build
	$(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@

# Applica il pattern solo a un elenco specifico di target
OBJS := main.o utils.o io.o

$(OBJS): %.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

# Sintassi: targets: target-pattern: prereq-pattern
# Utile quando hai più pattern rules e vuoi evitare ambiguità

# Disabilitare una regola implicita specifica
%.o: %.s

# Disabilitare TUTTE le regole implicite
MAKEFLAGS += --no-builtin-rules
.SUFFIXES:

# foreach
DIRS := src lib test
SRCS := $(foreach d,$(DIRS),$(wildcard $(d)/*.c))

# if (espande then se condizione non vuota)
DEBUG_FLAGS := $(if $(DEBUG),-g -O0,-O2)

# or (primo valore non vuoto)
CC := $(or $(CUSTOM_CC),gcc)

# and (ultimo valore se tutti non vuoti, altrimenti vuoto)
RESULT := $(and $(CC),$(CFLAGS),ok)

# call (chiama una funzione definita dall'utente)
to_upper = $(shell echo $(1) | tr a-z A-Z)
NAME := $(call to_upper,hello)   # HELLO

# shell (esegue un comando e cattura stdout)
DATE  := $(shell date +%Y-%m-%d)
FILES := $(shell find src -name '*.c')

# value (valore non espanso di una variabile)
RAW := $(value CC)

# eval (espande e valuta come sintassi Makefile)
$(eval $(call genera_regola,modulo1))

# error / warning / info
$(error Messaggio fatale: build interrotto)
$(warning Attenzione: variabile non settata)
$(info Build avviato alle $(DATE))

# ifeq / ifneq — confronto tra stringhe
ifeq ($(CC),gcc)
  CFLAGS += -Wno-unused-result
else ifeq ($(CC),clang)
  CFLAGS += -Wno-unused-command-line-argument
else
  CFLAGS += -W
endif

# ifdef / ifndef — verifica se la variabile è definita
ifdef DEBUG
  CFLAGS += -g -O0 -DDEBUG
else
  CFLAGS += -O2 -DNDEBUG
endif

# Uso dalla riga di comando: make DEBUG=1

# Confronto con stringa vuota
ifeq ($(VERBOSE),)
  Q := @           # silenzia i comandi
else
  Q :=             # mostra i comandi
endif

%.o: %.c
	$(Q)$(CC) $(CFLAGS) -c $< -o $@

UNAME_S := $(shell uname -s)

ifeq ($(UNAME_S),Linux)
  LDLIBS += -lrt -lpthread
endif
ifeq ($(UNAME_S),Darwin)
  CC := clang
  LDLIBS += -framework CoreFoundation
endif

# Rilevamento Windows (MinGW / MSYS)
ifdef COMSPEC
  RM = del /Q
  EXE = .exe
else
  RM = rm -f
  EXE =
endif

# Include un altro Makefile
include config.mk
include $(wildcard deps/*.d)

# -include (o sinclude): non dà errore se il file non esiste
-include $(OBJ:.o=.d)

# Uso tipico: file .d per dipendenze automatiche (vedi sezione dedicata)
# Uso tipico: config.mk per variabili specifiche dell'ambiente

# Makefile principale che invoca sub-make
SUBDIRS := src lib tests

.PHONY: all clean $(SUBDIRS)

all: $(SUBDIRS)

$(SUBDIRS):
	$(MAKE) -C $@

# Dipendenze tra sottodirectory
src: lib
tests: src

clean:
	for dir in $(SUBDIRS); do $(MAKE) -C $$dir clean; done

# Struttura:
#   src/main.c src/utils.c
#   lib/parser.c lib/lexer.c
#   build/  (output)

SRCDIR  := src
LIBDIR  := lib
BUILDDIR:= build

SRC     := $(wildcard $(SRCDIR)/*.c) $(wildcard $(LIBDIR)/*.c)
OBJ     := $(patsubst %.c,$(BUILDDIR)/%.o,$(notdir $(SRC)))
TARGET  := $(BUILDDIR)/prog

VPATH   := $(SRCDIR) $(LIBDIR)

$(TARGET): $(OBJ) | $(BUILDDIR)
	$(CC) $(LDFLAGS) $^ -o $@ $(LDLIBS)

$(BUILDDIR)/%.o: %.c | $(BUILDDIR)
	$(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@

$(BUILDDIR):
	mkdir -p $@

# VPATH: lista di directory dove cercare i prerequisiti
VPATH = src:lib:include

# vpath (minuscolo): più selettivo, per pattern
vpath %.c src lib
vpath %.h include

# Con vpath Make cerca automaticamente i .c nelle directory specificate
# quando un prerequisito non viene trovato nella directory corrente

clean:
	@echo "Pulizia in corso..."    # @ = non stampare il comando
	-rm -f *.o                      # - = non fallire se non ci sono .o
	@echo "Fatto."

submake:
	+$(MAKE) -C subdir              # + = esegui anche con make -n

# Ogni riga della recipe è eseguita in una shell separata!
bad:
	cd subdir
	ls            # NON lista subdir! Il cd si è perso

# Soluzione 1: una riga sola con ;
good1:
	cd subdir; ls

# Soluzione 2: backslash per continuazione
good2:
	cd subdir && \
	ls && \
	pwd

# Soluzione 3: .ONESHELL (GNU Make 3.82+)
.ONESHELL:
good3:
	cd subdir
	ls
	pwd

# $ in una recipe: bisogna raddoppiare per la shell
list:
	for f in *.c; do echo $$f; done
# $$ diventa $ per la shell, $f è la variabile shell
# Un singolo $ verrebbe interpretato da Make

# Accedere a variabili d'ambiente nella recipe
info:
	@echo "User: $$USER"
	@echo "CC:   $(CC)"

CC      := gcc
CFLAGS  := -Wall -g
DEPFLAGS= -MMD -MP

SRC     := $(wildcard *.c)
OBJ     := $(SRC:.c=.o)
DEP     := $(SRC:.c=.d)

prog: $(OBJ)
	$(CC) $(LDFLAGS) $^ -o $@ $(LDLIBS)

%.o: %.c
	$(CC) $(CPPFLAGS) $(CFLAGS) $(DEPFLAGS) -c $< -o $@

-include $(DEP)

clean:
	$(RM) $(OBJ) $(DEP) prog

# main.d generato da gcc -MMD -MP main.c
main.o: main.c main.h utils.h config.h

main.h:
utils.h:
config.h:
# Le regole vuote (-MP) evitano errori se un header viene cancellato

# Stampare il valore di una variabile
$(info CFLAGS = $(CFLAGS))
$(warning SRC = $(SRC))            # come info ma con file:linea

# Target di debug
print-%:
	@echo '$* = $($*)'
# Uso: make print-CFLAGS  make print-SRC  make print-OBJ

# Ispezionare l'origine di una variabile
$(info origin CC = $(origin CC))
# Possibili valori: undefined, default, environment,
# file, command line, override, automatic

# Ispezionare il flavor di una variabile
$(info flavor CFLAGS = $(flavor CFLAGS))
# Possibili valori: undefined, recursive, simple

# ERRORE: *** missing separator.  Stop.
# Causa: spazi invece di TAB nella recipe
# Fix: usare TAB reali (non soft-tab del tuo editor)

# ERRORE: No rule to make target 'file.h'
# Causa: file .d obsoleto riferisce un header cancellato
# Fix: aggiungere -MP alle DEPFLAGS, oppure make clean

# ERRORE: circular dependency dropped
# Causa: un target dipende (direttamente o indirettamente) da sé stesso

# Il target non viene ricompilato nonostante modifiche
# Causa: dipendenze incomplete (manca un header nelle dipendenze)
# Fix: usare le dipendenze automatiche (-MMD -MP)

# ── Progetto C con dipendenze automatiche, build dir, debug/release ──

# Compilatore e flag
CC       := gcc
CFLAGS   := -Wall -Wextra -Wpedantic -std=c17
CPPFLAGS := -I./include
LDFLAGS  :=
LDLIBS   := -lm
DEPFLAGS  = -MMD -MP -MF $(DEPDIR)/$*.d

# Directory
SRCDIR   := src
BUILDDIR := build
DEPDIR   := $(BUILDDIR)/deps

# File
SRC      := $(wildcard $(SRCDIR)/*.c)
OBJ      := $(patsubst $(SRCDIR)/%.c,$(BUILDDIR)/%.o,$(SRC))
DEP      := $(patsubst $(SRCDIR)/%.c,$(DEPDIR)/%.d,$(SRC))
TARGET   := $(BUILDDIR)/prog

# Debug/Release
ifdef DEBUG
  CFLAGS += -g3 -O0 -DDEBUG
else
  CFLAGS += -O2 -DNDEBUG
endif

# ── Target principali ──
.PHONY: all clean rebuild help

all: $(TARGET)

$(TARGET): $(OBJ) | $(BUILDDIR)
	$(CC) $(LDFLAGS) $^ -o $@ $(LDLIBS)
	@echo "Build completato: $@"

$(BUILDDIR)/%.o: $(SRCDIR)/%.c | $(BUILDDIR) $(DEPDIR)
	$(CC) $(CPPFLAGS) $(CFLAGS) $(DEPFLAGS) -c $< -o $@

# ── Directory ──
$(BUILDDIR) $(DEPDIR):
	mkdir -p $@

# ── Pulizia ──
clean:
	$(RM) -r $(BUILDDIR)

rebuild: clean all

# ── Help ──
help:
	@echo "Target disponibili:"
	@echo "  all      - Compila il progetto (default)"
	@echo "  clean    - Rimuove i file generati"
	@echo "  rebuild  - Clean + build"
	@echo "  help     - Mostra questo messaggio"
	@echo ""
	@echo "Variabili:"
	@echo "  DEBUG=1  - Compila con simboli di debug"
	@echo "  CC=clang - Usa un compilatore diverso"

# ── Dipendenze automatiche ──
-include $(DEP)

LIB     := libutils.a
LIB_SRC := $(wildcard lib/*.c)
LIB_OBJ := $(LIB_SRC:.c=.o)

$(LIB): $(LIB_OBJ)
	$(AR) $(ARFLAGS) $@ $^

# Linkare il programma alla libreria
prog: main.o $(LIB)
	$(CC) $(LDFLAGS) main.o -L. -lutils -o $@

SHLIB     := libutils.so
SHLIB_SRC := $(wildcard lib/*.c)
SHLIB_OBJ := $(SHLIB_SRC:.c=.o)

# Compilare con -fPIC per shared library
lib/%.o: lib/%.c
	$(CC) $(CFLAGS) -fPIC -c $< -o $@

$(SHLIB): $(SHLIB_OBJ)
	$(CC) -shared $^ -o $@

# Linkare ed eseguire
prog: main.o $(SHLIB)
	$(CC) $(LDFLAGS) main.o -L. -lutils -o $@
# Esecuzione: LD_LIBRARY_PATH=. ./prog

# Sopprimere "Nothing to be done" e "is up to date"
all: prog
	@:                          # : = comando nullo della shell

# Forzare la ricompilazione di un target
.PHONY: FORCE
FORCE:
version.o: FORCE            # sempre ricompilato

# Stampare un separatore colorato
build: $(TARGET)
	@printf '\033[32m=== Build OK ===\033[0m\n'

# Creare automaticamente le directory per gli output
$(BUILDDIR)/%.o: %.c
	@mkdir -p $(@D)
	$(CC) $(CFLAGS) -c $< -o $@

# Target help auto-documentante
help: ## Mostra questo messaggio
	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | \
	  awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-15s\033[0m %s\n", $$1, $$2}'

# Timestamp di build
CPPFLAGS += -DBUILD_DATE='"$(shell date)"'
CPPFLAGS += -DGIT_HASH='"$(shell git rev-parse --short HEAD 2>/dev/null || echo unknown)"'

# Check se un programma è installato
check-deps:
	@command -v $(CC) >/dev/null 2>&1 || { echo "$(CC) non trovato"; exit 1; }

# Compilazione condizionale con feature flags
ifdef WITH_SSL
  CPPFLAGS += -DWITH_SSL
  LDLIBS   += -lssl -lcrypto
endif