Compilar con Make

Make sirve para organizar la compilación de código. Vamos a ver una introducción a make que nos servirá para compilar pequeños y medianos proyectos. Evidentemente las cosas que se pueden hacer con Make son muchas mas de las que voy a enseñar, pero básicamente es capaz de:

  • Make puede saber que archivo o cabecera necesita compilar lo que es muy útil cuando compilamos muchas y pesadas librerías .
  • guarda los comando que usamos para compilar, por tanto en cada compilación no tenemos que escribir todos los comandos.

Si quereis profundizar en el tema https://linux.die.net/man/1/make.

Imaginemos que tenemos 3 archivos en nuestro programa: dos con código c y un archivo de cabecera. Es muy frecuente organizar el código de esta manera en c. Tenemos main.c donde se encuentra el hilo principal del programa y leer_configuracion.c que tiene una función que lee alguna configuración. Ademas tenemos el leer_configuracion.h que es la cabecera del anterior. Estos archivos los mostramos a continuación:

leer_configuracion.c

#include 
#include 
#include 

int leer_configuracion()
{
	printf("leyendo configuracion\n");
	return EXIT_SUCCESS;
}

leer_configuracion.h

int leer_configuracion();

main.c

#include 

int main() {
  // call a function in another file
  leer_configuracion();
  leer_configuracion2();

  return(0);
}

Una compilación típica seria:

gcc -o conf main.c leer_configuracion.c -I.

la opción -o es para especificar el nombre del archivo ejecutable, -I. indica que lea los .h en el directorio actual (.). La compilación anterior nos genera el ejecutable “conf” que ejecutamos con ./conf

¿Cómo hacer un makefile?

El problema del siguiente make es que recompila todo. Algo importante es que tiene que haber una tabulación donde empieza el código del make en gcc. Es decir cuidado al copiar y pegar el código: dale a borrar el espacio y metes el tabulador

compilame: main.c leer_configuracion.c
  gcc -o conf main.c leer_configuracion.c -I.

En el siguiente make hemos usado las constantes CC y CFLAGS. Estas comunican a make como queremos compilar leer_configuracion.c y main.c La macro CC es el compilador que vamos a usar y CFLAGS la lista de flags para pasar al compilador.
Poniendo los ficheros objeto (main.o y leer_configuracion.o) en la lista de dependencias y en las reglas, make sabe que primero debe compilar los .c primero individualmente y luego construir el ejecutable conf

CC=gcc
CFLAGS=-I.
compilame: main.o leer_configuracion.o
  $(CC) -o conf main.c leer_configuracion.c $(CFLAGS)

En la siguiente make agregamos la macro DEPS que contiene el conjunto de los .h de los .c
A continuación definimos una regla que aplica a todos los archivos acabados en .o. La regla dice que el .o que depende del .c y del .h definido en el macro DEPS. Es decir que la regla para generar el archivo .o, make necesita compilar los .c usando el compilador definido en CC.

  • El flag -c dice que genere el archivo objeto .o.
  • El flag -o $@ dice que ponga el resultado de la compilacion en el archivo cuyo nombre está a la izquierda de : es decir en compilame,
  • El $< es el primer item en la lista de dependencias
CC=gcc
CFLAGS=-I.
DEPS = hellomake.h

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

compilame: main.o leer_configuracion.o
	$(CC) -o conf main.c leer_configuracion.c $(CFLAGS)  
Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s