Ir al nuevo Rincón del C

Visita La Tienda del Rincón del C

Recomienda esta web a un amigo

Introducción a Make (I)

1.- Introducción
****************

Este artículo está dirigido a aquellos que programen
usando gcc. Puede que sea válido también para
otros compiladores, pero no es seguro.

Cuando nuestros programas son sencillos (un sólo fichero)
compilarlo es muy sencillo. Basta con usar gcc:

gcc -o ejemplo.exe -c ejemplo.c

Sin embargo si tenemos dos ficheros la compilación será más
compleja:

gcc -c ejemplo1.c
gcc -c ejemplo2.c
gcc -o ejemplo.exe ejemplo1.c ejemplo2.c

Eso suponiendo que sólo usemos dos ficheros. Un proyecto real
será mucho más complejo, por eso debemos usar una herramienta
que nos facilite la tarea de compilación. Esa herramienta es
Make.

La mayoría de los IDE (entornos de desarrollo integrado)
que existen realizan esta tarea automáticamente, pero siempre
es conveniente conocer cómo funciona.

2.- Dónde conseguirlo
*********************

Para DJGPP:

Lo puedes encontrar en
ftp://ftp.rediris.es/mirrror/simtelnet/gnu/djgpp/v2gnu

Para Linux:
Se incluye "de serie" en casi todas las distribuciones de
Linux.


3.- Un primer ejemplo
*********************

Para empezar a conocerlo vamos a utilizar make para compilar
un programa que ya es todo un clásico ligeramente modificado:

Fichero: ejemplo.c
-------------------------------
#include <stdio.h>
int main() {
	printf("Hola make\n");
}
-------------------------------

Para usar make lo primero que debemos hacer es crear un fichero
llamado Makefile en el directorio donde tengamos guardado ejemplo.c.
Este fichero contiene las instrucciones para el programa make.

Fichero: Makefile
-------------------------------
ejemplo.exe: ejemplo.c
	gcc -o ejemplo.exe ejemplo.c
-------------------------------

Para compilar el programa basta con teclear 'make' en la línea de
comando. En el siguiente apartado vamos a analizar este Makefile.

4.- Cómo funciona nuestro primer Makefile
*****************************************

El fichero Makefile es el que indica a make cómo tiene que compilar
nuestro programa. Está compuesto por reglas que tienen el siguiente
formato:

objetivo: requisitos
	comandos

El objetivo (o target en inglés) es el nombre de la acción que va a
realizar make, normalmente el fichero que queremos obtener. En nuestro
ejemplo es el nombre del ejecutable 'ejemplo.exe'. En el apartado
'requisitos' debemos poner los ficheros que deben existir o las otras
reglas que deben ejecutarse primero.

A continuación debemos poner los comandos que se deben ejecutar.
Aquí es donde indicamos a make que invoque a gcc para compilar
el programa (gcc -o ejemplo.exe ejemplo.c).

Este ejemplo funciona perfectamente pero sería más correcto de
esta otra forma:

Fichero: Makefile
-------------------------------
ejemplo.exe: ejemplo.o
	gcc -o ejemplo.exe ejemplo.o
ejemplo.o: ejemplo.c
	gcc -c ejemplo.c
-------------------------------

Para el que los desconozca, los ficheros *.o son ficheros objeto.
Para más información sobre estos ficheros recomiendo la lectura
del artículo:
http://www.elrincondelc.com/comos/comogcc.html

En este segundo Makefile tenemos dos reglas. La primera (la que
se ejecuta si no indicamos nada al llamar a make) tiene como
requisito la regla ejemplo.o. Make busca la regla ejemplo.o.
Esta regla tiene como requisito la regla ejemplo.c. Make busca
la regla 'ejemplo.c' y al no encontrarla supone que es un fichero.
Si no existiera este fichero make lanzaría un mensaje de error.

5.- Un Makefile más complejo
****************************

Ahora supongamos un proyecto que está compuesto de dos fuentes
*.c y uno de ellos necesita un fichero *.h

Fichero: Makefile
-------------------------------
ejemplo.exe: ejemplo1.o ejemplo2.o
	gcc -o ejemplo.exe ejemplo1.o ejemplo2.o
ejemplo1.o: ejemplo1.c ejemplo1.h
	gcc -c ejemplo1.c
ejemplo2.o: ejemplo2
	gcc -c ejemplo2.c
clean:
	del *.o
-------------------------------

(en este ejemplo hemos añadido también la regla 'clean' que
se puede invocar directamente usando 'make clean'. Con
esta regla borramos todos los ficheros *.o para tener limpio
el directorio de nuestro proyecto)

La ventaja adicional de usar make es que nos ahorra tiempo de
compilación ya que sólo compila los ficheros que sean necesarios.
Si ya tenemos compilado el proyecto y modificamos sólo el fichero
ejemplo2.c, make sólo compilará ese fichero.

* Más información:
******************
Consulta la documentación de Make (info make).