Make akefile.html

Make El comando de linux make se usa en proyectos grandes, en los que hay muchos ficheros fuente (.c) y módulos (.o). Make tiene en cuenta las dependencias entre módulos. Make determina si un conjunto de ficheros debe ser compilados, basándose en las fechas de última modificación de los ficheros destino y en las de los ficheros fuente, es decir, si uno de los ficheros fuente, necesario para crear un fichero destino, es más reciente que el fichero destino, un conjunto de comandos serán ejecutados. El propósito de estos comandos es actualizar el fichero destino.

Make El fichero destino es el 'objetivo' y los ficheros fuente son los 'prerrequisitos'. Los comandos se ejecutan si uno de los 'prerrequisitos' es más reciente que el fichero destino (o si el destino no existe). Si todos los prerrequisitos son igual o más antiguos que el destino, entonces los comandos no se ejecutan y el fichero destino se considera actualizado. En el directorio de trabajo actual, se debería crear un fichero con el nombre Makefile, GNUmakefile, makefile. Este fichero contiene la información que necesita make para realizar su trabajo de manera adecuada. Una vez que se tiene el Makefile (con 'M' mayúscula), la única cosa que hay que hacer es: teclear 'make' y los comandos necesarios para crear un nuevo fichero destino se ejecutan automáticamente.

Make INC-DIR = -I. -I../include -I/usr/X11R6/include -I/usr/local/include LIB-DIR = -L. -L/usr/X11/lib -L -L/usr/local/lib -L/usr/X11R6/lib GCC = gcc CFLAGS = -ansi -pedantic -Wall all: eem eem: eem.o feem.o $(GCC) $(CFLAGS) $(LIB-DIR) -o eem eem.o feem.o -lRai -lforms -lX11 -lm eem.o: eem.c $(GCC) $(CFLAGS) $(INC-DIR) -c eem.c feem.o: feem.c $(GCC) $(CFLAGS) $(INC-DIR) -c feem.c clean: rm -f *.o

Make $make (Busca el objetivo principal)‏ objetivo principal: la parte izquierda de la primera regla que contiene “:”. Ejm:all que sacamos de la regla “all:eem” Empieza a procesar el objetivo de la primera regla: all: eem Encuentra que esta tiene una dependencia eem, por lo que va a buscar si hay un objetivo del tipo eem. En caso de que exista procesa dicho objetivo dejando el anterior a la espera de que termine este último. Y así sucesivamente hasta procesar todas las dependencias. En caso de que una dependencia no este como objetivo hará que el make la busque como fichero en la carpeta actual en caso de que no la encuentre dará un error. En caso de encontrar los archivos ejecutará la orden correspondiente, subiendo en la jerarquía hasta llegar al objetivo principal. Decir que puede haber objetivos que no tengan ninguna dependencia como clean.

Make Ventajas:  Al compilar con make sólo se recompilarán aquellos ficheros que dependan del que hemos modificado.  Nos guarda los comandos de compilación con todos sus parámetros para encontrar librerías, ficheros de cabecera (.h),...  No tendremos que escribir largas líneas de compilación con montones de opciones que debemos saber de memoria, o al menos, sólo tendremos que hacerlo una vez.

Make Ventajas:  Make sólo compila si alguna de las fuentes tiene una fecha superior al ejecutable. $ls ->Holamundo.c $make Holamundo $./Holamundo less makefile Holamundo: Holamundo.o gcc Holamundo.o -o Holamundo Holamundo.o: Holamundo.c gcc -c -o Holamundo.o Holamundo.c

Make Make lee del fichero Makefile que contiene reglas: Cuando tenemos más de un programa fuente, hay que decirle que queremos que haga: objetivo: dependencia1 dependencia2... comando1 comando2...

Make Objetivo: Es el nombre del ejecutable o librería. dependencia es el nombre de otro objetivo que debe hacerse antes que el nuestro o bien ficheros de los que depende nuestro objetivo. es un tabulador comando es lo que se tiene que ejecutar para construir nuestro objetivo

Make

Ejm: HolaMundo: HolaMundo.c../FUNCION1/funcion1.c../FUNCION1/funcion1.h gcc -I../FUNCION1 HolaMundo.c../FUNCION1/funcion1.c -o HolaMundo

Make Mejora: HolaMundo: HolaMundo.o../FUNCION1/funcion1.o gcc HolaMundo.o../FUNCION1/funcion1.o -o HolaMundo../FUNCION1/funcion1.o:../FUNCION1/funcion1.c gcc -c../FUNCION1/funcion1.c -o../FUNCION1/funcion1.o HolaMundo.o: HolaMundo.c gcc -c -I../FUNCION1 HolaMundo.c -o HolaMundo.o

Make:Variables Es muy habitual que existan variables en los ficheros Makefile, para facilitar su portabilidad a diferentes plataformas y entornos. La forma de definir una variable es muy sencilla, basta con indicar el nombre de la variable (típicamente en mayúsculas) y su valor, de la siguiente forma: CC = gcc –O2 Cuando queramos acceder al contenido de esa variable, lo haremos así: $(CC) juego.c –o juego

Make:Variables Es necesario tener en cuenta que la expansión de variables puede dar lugar a problemas de expansiones recursivas infinitas, por lo que a veces se emplea esta sintaxis: CC := gcc CC := $(CC) –O2 Empleando “:=” en lugar de “=” evitamos la expansión recursiva y por lo tanto todos los problemas que pudiera acarrear.

Make:Variables Ejm: Variables definidas en makefile:  En CFLAGS se escriben los parametros que queremos pasar al compilador. Ejm: CFLAGS = -I - I -g...  OBJETOS=...  FUENTES=...

Make:Variables OBJETOS=HolaMundo.o../FUNCION1/funcion1.o CFLAGS=-I../FUNCION1 HolaMundo: $(OBJETOS) gcc $(OBJETOS) -o HolaMundo../FUNCION1/funcion1.o:../FUNCION1/funcion1.c gcc -c../FUNCION1/funcion1.c -o../FUNCION1/funcion1.o HolaMundo.o: HolaMundo.c gcc -c $(CFLAGS) HolaMundo.c -o HolaMundo.o

Make:Variables Además de las variables definidas en el propio Makefile, es posible hacer uso de las variables de entorno, accesibles desde el intérprete de comandos. Esto puede dar pie a formulaciones de este estilo: SRC = $(HOME)/src juego: gcc $(SCR)/*.c –o juego

Make:Variables predefinidas Variables que tienen un valor por defecto para el make: AS: Nombre del programa ensamblador.Por defecto: as CC: Nombre de programa para compilar en C.Por defecto:gcc CPP: Nombre del preprocesador g++. Por defecto:$(CC) -E CFLAGS=Opciones del compilador de C RM=Borrar ficheros.Por defecto: rm –f (sin confirmación)‏

Make:Variables automáticas Un tipo especial de variables lo constituyen las variables automáticas, aquellas que se evalúan en cada regla: Se sustituye por el nombre del objetivo de la presente regla $* Nombre del archivo objetivo sin extensión $+ Nombre de todos los archivos de las dependencias $< Nombre del primer archivo de las dependencias $? Nombre de todos los archivos de las dependencias que son más modernos que el objetivo, con espacios entre ellos.

Make:Variables automáticas CC=gcc CFLAGS=-g OBJECTS=geometria.o area.o volumen.o todo all: geometria geometria: $(OBJECTS)‏ $(CC) -o $(OBJECTS)‏.... eliminar clean: $(RM) geometria $(OBJECTS)‏

Resumen:makefile,,... son directorios donde tengas ficheros.h de tu proyecto. No hace falta que pongas los del sistema (stdio.h y demás), que esos se ponen solos.,,... son los.o de tu proyecto, es decir, todos y cada uno de los.c, pero cambiándoles la extensión por.o. Estos objetos deben incluir el path donde están los.c. Por ejemplo, si tengo..../directorio1/fichero.c, uno de los objetos será..../directorio1/fichero.o

Resumen:makefile,,... son los fuentes, igual que los,, pero terminados en.c en vez de.o y también con el path. es un tabulador. Es importante que esté ahí, si no obtendremos errores. Cada vez que en tu proyecto generes.h o.c nuevos o cambies los includes de las fuentes ya existentes, actualiza el fichero Makefile (FUENTES, OBJETOS y CFLAGS). Cuando quieras compilar:$ make

Ejemplo En define.h #ifndef _DEFINE_H #define _DEFINE_H #define PI #endif En volumen.h #ifndef _VOLUMEN_H #define _VOLUMEN_H int cubo (int x); float esfera (int x); #endif En area.h #ifndef _AREA_H #define _AREA_H int cuadrado (int x); float circulo (int x); #endif

Ejemplo En area.c #include "define.h" int cuadrado (int x)‏ {return x*x;} float circulo (int x)‏ {return PI*x*x;} En volumen.c #include "define.h" int cubo (int x)‏ {return x*x*x;} float esfera (int x)‏ {return 4*PI*x*x*x/3;}

Ejemplo En geometria.c #include #include "area.h" #include "volumen.h" int main(){ int lado,radio; printf("Introduce el lado \n"); scanf("%d",&lado); printf("Introduce el radio \n"); scanf("%d",&radio); printf("El cubo es %d \n",cubo(lado)); printf("La esfera es %f \n",esfera(radio)); printf("El cuadrado es %d \n",cuadrado(lado)); printf("El circulo %f \n",circulo(radio)); return 0; }

Ejemplo:sin librerías gcc -I. -c volumen.c -o volumen.o gcc -I. -c area.c -o area.o gcc -I. volumen.o area.o geometria.c -o geometria

Ejemplo:librerías estáticas gcc -I. -c volumen.c -o volumen.o gcc -I. -c area.c -o area.o ar -rv libgeneral.a volumen.o area.o ranlib libgeneral.a nm –s libgeneral.a gcc -I. geometria.c libgeneral.a -o geometria

Ejemplo:librerías dinámicas gcc -I. -c volumen.c -o volumen.o gcc -I. -c area.c -o area.o ld -o libgeneral.so volumen.o area.o --shared gcc -o geometria geometria.c -Bdynamic libgeneral.so //ldd geometria ->analiza que librerías dinámicas necesita geometria //dice:libgeneral.so => not found LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/kepa/lana export LD_LIBRARY_PATH //ldd geometria ->analiza que librerías dinámicas necesita geometria./geometria

Ejemplo:Make vi makefile geometria: area.o volumen.o geometria.o gcc geometria.o area.o volumen.o -o geometria volumen.o:volumen.c define.h gcc –I. -c volumen.c -o volumen.o area.o:area.c define.h gcc –I. -c area.c -o area.o geometria.o: geometria.c volumen.h area.h gcc –I. -c geometria.c -o geometria.o