Aprende X en Y minutos

# Los comentarios se pueden escribir de esta forma.

# El fichero debe tener el nombre de Makefile y luego puede ser ejecutado
# como `make <objetivo>`.
# De lo contrario, se utiliza `make -f "nombre_archivo" <objetivo>`

# Advertencia: ¡solo use TABULACIONES para la identación en Makefiles, nunca
# espacios!

#-----------------------------------------------------------------------
# Fundamentos
#-----------------------------------------------------------------------

# Las reglas tienen el formato
# objetivo: <prerrequisito>
# donde prerrequisito es opcional.

# Una regla - esta regla solamente se ejecutará si file0.txt no existe.
file0.txt:
    echo "foo" > file0.txt
    # Incluso los comandos en esta sección de 'receta' se pasan a la shell.
    # Prueba `make file0.txt` o  simplemente 'make' - La primera regla es la
    # predeterminada.

# Esta regla se ejecutará solo si file0.txt es más reciente que file1.txt.
file1.txt: file0.txt
    cat file0.txt > file1.txt
    # Use las mismas reglas de comillas que en la shell.
    @cat file0.txt >> file1.txt
    # @ evita que el comando se muestre en stdout.
    -@echo 'hello'
    # - Quiere decir que make continuará en caso de error.
    # Pruebe 'make file1.txt` en la línea de comandos.

# Una regla puede tener múltiples objetivos y múltiples prerrequisitos
file2.txt file3.txt: file0.txt file1.txt
    touch file2.txt
    touch file3.txt

# Make se quejará de múltiples recetas para la misma regla. Sin embargo,
# las reglas vacías no cuentan y se pueden utilizar para agregar nuevas
# dependencias

#-----------------------------------------------------------------------
# Objetivos ficticios (Phony Targets)
#-----------------------------------------------------------------------

# Un objetivo ficticio (phony target). Cualquier objetivo que no sea un archivo.
# Nunca estará actualizado, por lo que make siempre tratará de ejecutarlo.
all: make process

# Podemos declarar cosas sin orden.
maker:
    touch ex0.txt ex1.txt

# Se puede evitar que las reglas ficticias (phony) se rompan cuando un archivo
# real tiene el mismo nombre usando:
.PHONY: all maker process
# Esto es un objetivo especial. Hay varios otros.

# Una regla con una dependencia en un objetivo ficticio (phony target)
# se ejecutara siempre:
ex0.txt ex1.txt: maker

# Los objetivos ficticios (phony target) más comunes son: 
# all make clean install...

#-----------------------------------------------------------------------
# Variables automáticas y Wildcards
#-----------------------------------------------------------------------

process: file*.txt  # usa un wildcard para coincidir con los nombres de archivos.
    @echo $^    # $^ es una variable que contiene una lista de todos los prerrequisitos
    @echo $@    # imprime el nombre del objetivo
    #(para reglas con múltiples objetivos, $@ es el que hizo que se ejecutara la regla)
    @echo $<    #  el primer prerrequisito listado
    @echo $?    # solo las dependencias que están desactualizadas
    @echo $+    # todas las dependencias incluyendo las duplicadas (a diferencia de lo normal)
    #@echo $|   # solo los 'prerrequisitos solicitados'

# Incluso si dividimos las definiciones de las dependencias, de las reglas, $^
# las encontrará
process: ex1.txt file0.txt
# ext1.xt se encontrará pero file0.txt se duplicará.

#-----------------------------------------------------------------------
# Patrones
#-----------------------------------------------------------------------

# Se puede instruir a make sobre como convertir ciertos tipos de archivos en
# otros archivos.

%.png: %.svg
    inkscape --export-png $^

# Las reglas de patrones solo harán algo si make decide crear el objetivo.

# Los directorios no suelen tenerse en cuenta al coincidir con reglas de
# patrones.
# Pero make intentará usar la regla más apropiada disponible.

small/%.png: %.svg
    inkscape --export-png --export-dpi 30 $^

# make usará la última versión de una regla de patrón que encuentre.
%.png: %.svg
    @echo esta regla es elegida

# Sin embargo make usará la primera regla de patrón que pueda construir el
# objetivo.
%.png: %.ps
    @echo esta regla no es elegida si *.svg y *.ps están ambas presentes

# Make ya tiene algunas reglas de patrón integradas.
# Por ejemplo, sabe cómo convertir archivos *.c en archivos *.o.

# En makefiles antiguos se solían utilizar las reglas de sufijo en lugar de las
# reglas de patrón
.png.ps:
    @echo esta regla es similar a una regla de patrón.

# Instruye a make sobre una regla de sufijo
.SUFFIXES: .png

#-----------------------------------------------------------------------
# Variables
#-----------------------------------------------------------------------
# también conocidas como macros.

# Las variables son básicamente de tipo cadena (string)

name = Ted
name2="Sarah"

echo:
    @echo $(name)
    @echo ${name2}
    @echo $name    # Esto no funcionará, se tratará como $(n)name.
    @echo $(name3) # Variables desconocidas se tratarán como cadenas vacías.

# Hay 4 lugares donde se pueden definir variables.
# En orden de prioridad de mayor a menor:
# 1: argumentos de línea de comando.
# 2: Makefile.
# 3: variables de entorno de la shell - make las importa automáticamente.
# 4: make tiene algunas variables predefinidas.

name4 ?= Jean
# Solo establece la variable si la variable de entorno no está aún definida.

override name5 = David
# Detiene que los argumentos de línea de comandos modifiquen esta variable.

name4 +=grey
# Añade valores a la variable (incluye un espacio).

# Valores de variables específicos de patrones (Extension de GNU).
echo: name2 = Sara # Verdadero dentro de la regla coincidente
    # y también dentro de sus dependencias recursivas rehechas
    # (¡excepto que puede romperse cuando el grafo se complica demasiado!)

# Algunas variables son definidas automáticamente por make.
echo_inbuilt:
    echo $(CC)
    echo ${CXX}
    echo $(FC)
    echo ${CFLAGS}
    echo $(CPPFLAGS)
    echo ${CXXFLAGS}
    echo $(LDFLAGS)
    echo ${LDLIBS}

#-----------------------------------------------------------------------
# Variables 2
#-----------------------------------------------------------------------

# El primer tipo de variables se evalúan cada vez que se usan.
# Esto puede ser costoso, por lo que existe un segundo tipo de variable que se
# evalúa solo una vez. (Esta es una extensión de GNU make)

var := hello
var2 ::=  $(var) hello
#:= y ::= son equivalentes

# Estas variables se evalúan de manera procedimental (en el orden en que
# aparecen), ¡rompiendo así con el resto del lenguaje!

# Esto no funciona
var3 ::= $(var4) and good luck
var4 ::= good night

#-----------------------------------------------------------------------
# Funciones
#-----------------------------------------------------------------------

# make tiene muchas funciones disponibles.

sourcefiles = $(wildcard *.c */*.c)
objectfiles = $(patsubst %.c,%.o,$(sourcefiles))

# El formato es $(func arg0,arg1,arg2...)

# Algunos ejemplos
ls: * src/*
    @echo $(filter %.txt, $^)
    @echo $(notdir $^)
    @echo $(join $(dir $^),$(notdir $^))

#-----------------------------------------------------------------------
# Directrices (Directives)
#-----------------------------------------------------------------------

# Incluye otros makefiles, útil para código de plataformas específicas
include foo.mk

sport = tennis
# Compilación condicional
report:
ifeq ($(sport),tennis)
    @echo 'game, set, match'
else
    @echo "They think it's all over; it is now"
endif

# También existe ifneq, ifdef, ifndef

foo = true

ifdef $(foo)
bar = 'hello'
endif