PDF de programación - make

Make



Juan José Moreno Moll


Ingeniería Informática



MAKE


1. Introducción.................................................................................................3
2. Fichero makefile ..........................................................................................3

2.1. Ejemplo de makefile sencillo........................................................................................... 4

2.2. Variables de un makefile ................................................................................................. 6

2.3. Reglas implícitas ............................................................................................................. 7

2.4. Otras características......................................................................................................... 8

3. Escribir un fichero makefile ........................................................................9

3.1. Contenidos de un makefile .............................................................................................. 9

3.2. Nombres de makefile....................................................................................................... 9

3.3. Incluir otros makefiles ................................................................................................... 10

4. Reglas en un makefile..................................................................................10

4.1. Sintaxis de las reglas ..................................................................................................... 10

4.2 Caracteres Comodín ....................................................................................................... 10

4.3. Reglas con varias etiquetas. Reglas múltiples............................................................... 11

4.4. Reglas de patrones estáticos .......................................................................................... 12



19-feb-02



2/13


Ingeniería Informática

1. Introducción



MAKE

Un programa escrito en C normalmente está compuesto por muchos archivos. Estos archivos
se van modificando según se va completando o cambiando el programa. Cada vez que se
modifica algún archivo del programa, éste debe recompilarse para generar un ejecutable del
programa actualizado. La modificación de un archivo del programa no implica que se deban
recompilar todos los archivos del programa. Sólo se debe recompilar el fichero modificado así
como otros ficheros que puedan depender del fichero modificado.

La utilidad make determina automáticamente qué archivos del programa deben ser
recompilados y las órdenes que se deben utilizar para recompilarlos. En programas muy
grandes nos ayuda a mantener el ejecutable totalmente actualizado. No debemos recordar las
dependencias entre archivos del programa ni las órdenes necesarios para compilar cada parte
del programa.

La utilidad make no sólo sirve para compilar programas en C. También se puede utilizar:

1) con otros lenguajes cuyo compilador se pueda ejecutar en una ‘shell’ (en la línea de

ordenes).

2) para tareas de instalación y actualización de aplicaciones.

Para usar el make debemos escribir un fichero llamado makefile. Este fichero describe las
relaciones entre ficheros y las ordenes que se deben ejecutar con cada archivo.

Si en un directorio existe el fichero makefile para ejecutar la utilidad make simplemente
debemos escribir en la línea de órdenes:

c:\...> make

Con esta orden make busca el fichero makefile y se encarga de ejecutar las ordenes contenidas
en el fichero makefile.

2. Fichero makefile

La utilidad make normalmente ejecuta las reglas contenidas en un archivo llamado makefile.
Es posible indicar a make que lea reglas de ficheros con un nombre diferente a éste, como se
verá más adelante.

Un makefile simple está compuesto por reglas que tienen la siguiente forma:

etiqueta ... : dependencias...



orden
orden
...

19-feb-02



3/13


Ingeniería Informática



MAKE

Una etiqueta es un rótulo que generalmente se refiere a un nombre de fichero. Este fichero es
aquel que queremos actualizar con esta regla. También hay etiquetas que indican la acción que
la regla realiza. Por ejemplo limpiar (ver en el ejemplo siguiente).

Una dependencia es un fichero que se usa en la regla. Si este fichero se modifica la regla se
active. Una regla puede depender de varios ficheros.

Una orden es la acción que make ejecuta si la regla se activa. Una regla puede ejecutar más de
una orden. Nota muy importante: Una línea con una orden empieza siempre con un
tabulador (no por varios caracteres espacio).

Una regla tiene un nombre (etiqueta) y dice como rehacer un fichero (mediante ordenes) si
algún fichero del que depende se modifica (dependencias).

2.1. Ejemplo de makefile sencillo

Éste es un ejemplo de un makefile que permite generar un ejecutable llamado prog.exe a partir
de un programa en C que tiene 3 ficheros: el programa principal prog.c, un archivo fuente
vector.c, y su archivo de cabecera vector.h.


todo: prog.exe

vector.o: vector.h vector.c

gcc -c vector.c -Wall

prog.o: prog.c vector.h


prog.exe: prog.o vector.o


limpiar:



del prog.o
del vector.o
del prog.exe

gcc -c prog.c -Wall

gcc prog.o vector.o -o prog.exe



Este makefile permite hacer dos cosas: crear un ejecutable actualizado del programa, y borrar
el fichero ejecutable y todos ficheros objetos del programa.

Para crear el ejecutable actualizado del programa hay que escribir en la línea de órdenes:

c:\...> make

Veamos que ocurre si ejecutamos la línea anterior.

19-feb-02



4/13


Ingeniería Informática



MAKE

En el ejemplo anterior tenemos una primera regla llamada ‘todo’. Esta regla no tiene órdenes
y sí tiene una dependencia ‘prog.exe’. Esta regla nos indica sólo que hay que ver si el fichero
prog.exe está actualizado. La regla que se encarga de actualizar el fichero prog.exe está más
abajo y tiene como etiqueta ‘prog.exe’.

La segunda regla tiene como etiqueta ‘vector.o’. La orden que contienen la regla es: gcc -c
vector.c -Wall que hace que el compilador construya el fichero objeto vector.o. Y tiene las
dependencias vector.c y vector.h. Esta orden se ejecutará si el fichero vector.c o el fichero
vector.h han sido modificados.

La tercera regla es semejante a la anterior.

La cuarta regla tiene como etiqueta a ‘prog.exe’. La orden de la regla hace que se construya el
fichero ejecutable ‘prog.exe’. Y sus dependencias son prog.o y vector.o. Esta regla se lanzara
si los ficheros indicados en las dependencias han sido modificados.

El funcionamiento de este makefile es el siguiente. Al ejecutar la utilidad make sin
argumentos se activa la primera regla del makefile. Esta regla es ‘todo’. Esta regla no tiene
órdenes que ejecutar, pero sí tiene una dependencia, ‘prog.exe’. La regla ‘todo’ lo único que
hace es activar la regla ‘prog.exe’. La regla ‘prog.exe’, a su vez, se activa si los ficheros
prog.o y vector.o se han modificado. Antes de ejecutar la orden asociada a la regla ‘prog.exe’
se comprueban si es necesario activar las reglas asociadas a los ficheros ‘vector.o’ y ‘ prog.o’.
La regla ‘prog.exe’ llama a las reglas ‘vector.o’ y ‘prog.o’. La regla ‘vector.o’ tiene
dependencias de los ficheros vector.c y vector.h. Como se ve ya no hay reglas asociadas a
estos ficheros por lo que la orden asociado a la regla ‘vector.o’ se ejecutará si alguno de los
ficheros indicados en sus dependencias han sido modificado. La regla ‘prog.o’ funciona
exactamente igual que la regla ‘vector.o’.

Para generar el fichero prog.exe en primer lugar se observa si se ha modificado alguno de los
siguientes ficheros: vector.c, vector.h y prog.c. En caso afirmativo se actualizan los ficheros
objetos vector.o y prog.o. Y en último lugar se construye el fichero ejecutable prog.exe a
partir de los ficheros objetos previamente actualizados. Un esquema de como el makefile
indica las dependencias entre los ficheros que forman el programa y el proceso de
actualización que sigue hasta construir un ejecutable prog.exe acorde con los ficheros fuente
(*.c y *.h) que se están manejando en ese momento puede ser:



prog.c



prog.o



prog.exe



vector.o

vector.h



vector.c



19-feb-02



5/13


Ingeniería Informática



MAKE

Como se ve al ejecutar la utilidad make se activan todas las reglas del makefile excepto la
regla ‘limpiar’. Esta regla se utiliza para eliminar los ficheros objeto y el fichero ejecutable y
puede tener sentido para forzar una compilación completa del programa. La línea de órdenes
necesaria para borrar el ejecutable y los objetos es:

c:\...> make limpiar

La utilidad make sin argumentos ejecuta la primera regla del makefile. Para ejecutar una regla
distinta hay que pasarle como argumento el nombre de la regla que queremos activar. Si por
ejemplo sólo quisiéramos obtener el fichero vector.o podríamos ejecutar:

c:\...> make vector.o

2.2. Variables de un makefile

En el makefile anterior hemos usado en varias líneas la orden ‘gcc’ y la lista de objetos
‘vector.o prog.o’. Estas palabras se repiten muchas veces por dentro del texto del makefile.
Estas cadenas se pueden sustituir por variables que se definen dentro del makefile.

Una variable se define de la forma siguiente:

nombre_variable= lista palabras a las que sustituye

Y se hace referencia a una variable dentro del makefile de la forma siguien