PDF de programación - Make. Un programa para controlar la recompilación

Make
Un programa para controlar la recompilación

Gerardo Aburruzaga García

[email protected]

Revisado y corregido por Francisco Palomo Lozano

[email protected]

Índice
1. Introducción a make

1.1. Cómo leer este manual . . . . . . . . . . . . . . . . . . . . . . . .

2. Un ejemplo sencillo de makefile

2.1. Cómo make procesa este makefile . . . . . . . . . . . . . . . . . .

3. Las macros simplifican el makefile

3.1. Macros predefinidas
. . . . . . . . . . . . . . . . . . . . . . . . .
3.2. Dejemos que make deduzca las órdenes . . . . . . . . . . . . . . .
3.3. Otro estilo de makefile . . . . . . . . . . . . . . . . . . . . . . . .
3.4. Reglas para limpiar el directorio . . . . . . . . . . . . . . . . . .

4. Cómo escribir un makefile

4.1. Contenido de un makefile . . . . . . . . . . . . . . . . . . . . . .
4.2. Qué nombre dar al makefile . . . . . . . . . . . . . . . . . . . . .

5. Cómo escribir las reglas

5.1. Sintaxis de una regla . . . . . . . . . . . . . . . . . . . . . . . . .
5.2. Objetivos falsos . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3. Ficheros vacíos como objetivos
. . . . . . . . . . . . . . . . . . .
5.4. Objetivos especiales incorporados . . . . . . . . . . . . . . . . . .
5.5. Objetivos múltiples en una regla . . . . . . . . . . . . . . . . . .
5.6. Reglas múltiples para un objetivo . . . . . . . . . . . . . . . . . .

6. Escritura de las órdenes en la regla

6.1. Visión de las órdenes . . . . . . . . . . . . . . . . . . . . . . . . .
6.2. Ejecución de las órdenes . . . . . . . . . . . . . . . . . . . . . . .
6.3. Errores en las órdenes
. . . . . . . . . . . . . . . . . . . . . . . .
Interrupción de make . . . . . . . . . . . . . . . . . . . . . . . . .
6.4.

7. Macros o variables

7.1. Macros predefinidas

. . . . . . . . . . . . . . . . . . . . . . . . .

8. Reglas implícitas

8.1. Uso de las reglas implícitas
. . . . . . . . . . . . . . . . . . . . .
8.2. Escritura de reglas implícitas (método de sufijos) . . . . . . . . .
8.3. Cancelación de una regla implícita . . . . . . . . . . . . . . . . .
8.4. Definición de una regla predeterminada . . . . . . . . . . . . . .

9. Cómo ejecutar make

9.1. Parámetros para especificar el makefile . . . . . . . . . . . . . . .
9.2. Parámetros para especificar el objetivo . . . . . . . . . . . . . . .
9.3. Parámetros para no ejecutar las órdenes . . . . . . . . . . . . . .
9.4. Parámetros para cambiar macros . . . . . . . . . . . . . . . . . .
9.5. Resumen de parámetros y opciones para make . . . . . . . . . . .

2
3

3
5

5
6
6
7
8

9
9
9

10
10
11
12
13
13
14

14
14
15
15
16

16
17

18
18
19
19
19

19
20
20
20
21
21

1

10.Un ejemplo real

10.1. Comentarios iniciales . . . . . . . . . . . . . . . . . . . . . . . . .
10.2. Macros configurables . . . . . . . . . . . . . . . . . . . . . . . . .
10.3. Macros no configurables . . . . . . . . . . . . . . . . . . . . . . .
10.4. Reglas principales de construcción e instalación . . . . . . . . . .
10.5. Reglas intermedias o secundarias . . . . . . . . . . . . . . . . . .
10.6. Reglas adicionales
. . . . . . . . . . . . . . . . . . . . . . . . . .
10.7. Reglas de borrado . . . . . . . . . . . . . . . . . . . . . . . . . .
10.8. Regla de distribución . . . . . . . . . . . . . . . . . . . . . . . . .
10.9. Utilización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2

22
22
23
23
24
25
25
26
27
27

Lista de makefiles

1. Makefile para un editor — primera versión . . . . . . . . . . . . .
2. Makefile para un editor — segunda versión . . . . . . . . . . . .
3. Makefile para un editor — tercera versión . . . . . . . . . . . . .
4. Makefile simplificado para el programa que saluda . . . . . . . .

4
7
7
18

1.

Introducción a make

El propósito de la utilidad make es determinar automáticamente qué piezas
o módulos de un programa necesitan ser recompilados, y ejecutar las órdenes
apropiadas para esta tarea.

Los ejemplos que se verán mostrarán programas en C++, pero make pue-
de usarse con cualquier otro lenguaje de programación cuyo compilador pueda
ejecutarse mediante una orden. De hecho, make no está limitado a compilar
programas. Puede usarse para describir cualquier tarea donde algunos ficheros
deban ser actualizados de alguna forma automáticamente a partir de otros ca-
da vez que estos últimos cambien. Un ejemplo de esto sería la confección de
documentos usando algún procesador de textos como groff o LATEX.
Antes de usar la orden make hay que escribir con el editor de textos favorito
un fichero llamado «el makefile» que describe las relaciones entre los ficheros
que componen el programa, así como las órdenes necesarias para actualizar cada
uno de ellos. Tratándose de un programa, normalmente el fichero ejecutable se
actualiza a partir de módulos objeto, que a su vez se construyen a partir de la
compilación de código fuente.

Una vez que existe el fichero makefile, cada vez que se modifique algún fuente,

o varios, la simple orden

make

bastará normalmente para la recompilación del programa. Pero lo bueno de
make es que no lo compila todo de nuevo, sino que basándose en los datos del
makefile y las fechas de última modificación que el sistema operativo guarda
para cada fichero, decide cuáles son los que deben ser actualizados, y para cada
uno de ellos ejecuta las órdenes apropiadas según se especifica en el makefile.

Por otra parte, mediante el uso de parámetros y opciones que se le pasan
a make, se puede controlar qué ficheros recompilar o cómo. Esto se verá más
adelante en §9.

2 UN EJEMPLO SENCILLO DE MAKEFILE

3

1.1. Cómo leer este manual

Las líneas marcadas como ésta expresan conceptos fundamentales que
debe memorizar.



Las secciones marcadas con este signo expresan características no tan funda- 

mentales, que pueden dejarse para una lectura posterior, cuando ya se conozca
mejor el programa.

2. Un ejemplo sencillo de makefile

Supongamos que hemos hecho un editor de textos que consiste en 8 fiche-
ros fuente en C++ y 3 ficheros de cabecera propios. Necesitamos un fichero
makefile que le diga a make cómo compilar y enlazar para obtener el editor.
Supondremos en nuestro ejemplo que todos los fuentes C++ incluyen la cabe-
cera "defs.h" pero que sólo aquéllos donde se definen las funciones de edición
incluyen "commands.h" y que solamente los que manejan las funciones de bajo
nivel, como por ejemplo los cambios en el búfer del editor, incluyen "buffer.h".

El programa make obtiene todos los datos del fichero makefile, que
habrá que escribir con un editor.



Para reconstruir el editor debe recompilarse cada fichero fuente C++ que
haya sido modificado. Si un fichero de cabecera ha cambiado, para asegurarnos,
debe recompilarse cada fichero fuente que incluya esa cabecera. Finalmente, si
cualquier fuente ha sido recompilado, deben enlazarse todos los módulos objeto,
ya recién hechos o ya provenientes de anteriores compilaciones, para producir el
nuevo ejecutable.

El makefile 1 presenta la primera versión de un fichero makefile que nos
permitirá compilar todos los módulos y enlazarlos cuando llegue el momento.
Las líneas largas las dividimos en dos mediante el signo \ seguido inmedia-

tamente de un salto de línea; esto las hace más fáciles de leer.

Cada fichero que es generado por un programa (esto es, todos los ficheros
excepto los fuentes y cabeceras) es el objetivo (“target” en inglés) de una regla.
En este ejemplo los objetivos son los módulos objeto, como main.o, kbd.o, etc.,
y el ejecutable, edit.

Cada objetivo debe aparecer al principio de una línea seguido por el signo

de dos puntos.

Tras los dos puntos vienen las dependencias del objetivo; esto es, todos los

ficheros que se usan para actualizarlo.

Un objetivo necesita recompilación o enlace (actualización) si y sólo si cual-
quiera de sus dependencias cambia. Además, cualquier dependencia debe ser
actualizada antes si lo necesita. En nuestro ejemplo, edit depende de cada uno
de los ocho módulos objeto; el fichero objeto main.o depende del fichero fuente
main.cpp y del fichero de cabecera defs.h; si cambia uno de éstos, edit debe
ser enlazado de nuevo, pero antes, main.o debe ser recompilado.

Tras el objetivo y los ‘:’ vienen las dependencias, separadas por blancos.



Por omisión, make empieza con la primera regla que encuentra en el makefile
(el default goal en inglés), sin contar aquéllas cuyo objetivo empieza con un

2 UN EJEMPLO SENCILLO DE MAKEFILE

4

edit: main.o kbd.o commands.o display.o \

insert.o search.o files.o utils.o

c++ -o edit main.o kbd.o commands.o display.o \

insert.o search.o files.o utils.o

main.o: main.cpp defs.h
c++ -c main.cpp

kbd.o: kbd.cpp defs.h commands.h

c++ -c kbd.cpp

commands.o: commands.cpp defs.h commands.h

c++ -c commands.cpp

display.o: display.cpp defs.h buffer.h

c++ -c display.cpp

insert.o: insert.cpp defs.h buffer.h

c++ -c insert.cpp

search.o: search.cpp defs.h buffer.h

c++ -c search.cpp

files.o: files.cpp defs.h buffer.h commands.h

c++ -c files.cpp

utils.o: utils.cpp defs.h
c++ -c utils.cpp

Makefile 1: Makefile para un editor — primera versión

punto. Por lo tanto pondremos en primer lugar la regla para el ejecutable,
edit. Las otras se procesan porque aparecen como dependencias de ésta.
Make hace la primera regla que encuentra en el makefile, si no se indica
otra cosa.



Tras cada línea que contiene la regla, es decir, el objetivo y sus dependencias,
vienen una o más líneas de órdenes para el intérprete de órdenes del sistema
operativo (shell), que dicen cómo actualizar el fichero objetivo. Estas líneas
empiezan con un tabulador, lo cual indica a make que son líneas de órdenes
que debe mandar a ejecutar. Observe que make no sabe nada acerca de cómo
funcionan las órdenes; es responsabilidad del programador el que éstas sean
correctas; todo lo que make hace es mandarlas a ejecución cada vez que el
objetivo necesite ser actualizado.

Tras la línea de ‘objetivo: dependencias’ vienen las líneas de órdenes
precedidas de un carácter tab (tabulador).



3 LAS MACROS SIMPLIFICAN EL MAKEFILE