Ir al contenido

Introducción a Patrones de Diseño en C++ con Qt4/1.9 El comando make

De Wikilibros, la colección de libros de texto de contenido libre.
Versión para imprimir esta pagina

El comando make[editar]

En lugar de correr la línea de comando del compilador directamente, comenzaremos a usar make[1] que simplifica enormemente el proceso de construcción cuando un proyecto involucra múltiples archivos fuente y librerías.


Hemos visto antes que qmake (sin argumentos) lee un archivo de proyecto y construye un Makefile. El Ejemplo 1.8 es una vista medianamente comentada de el Makefile generado por un simple proyecto llamado qapp.


Ejemplo 1.8[editar]

Ejemplo: Ejemplo 1.8 src/qapp/Makefile-abbreviated
# Extractos de un makefile

####### Compilador, herramientas y opciones

CC            = gcc     # ejecutable para el compilador C
CXX           = g++     # ejecutable  para el compilador C++
LINK          = g++     # ejecutable para el enlazador

# marcas para ser pasadas al compilador
CFLAGS        = -pipe -g -Wall -W -D_REENTRANT $(DEFINES)
CXXFLAGS      = -pipe -g -Wall -W -D_REENTRANT $(DEFINES)
INCPATH       = -I/usr/local/qt/mkspecs/default -I. \
                -I$(QT4)/include/QtGui -I$(QT4)/include/QtCore \
                -I$(QT4)/include

# marcas del enlazador
LIBS          = $(SUBLIBS) -L$(QT4)/lib -lQtCore_debug -lQtGui_debug -lpthread
LFLAGS        = -Wl,-rpath,$(QT4)/lib

# macros para realizar otras operaciones como parte de los pasos de construcción:
QMAKE         = /usr/local/qt/bin/qmake

####### Archivos

HEADERS       =    # Si tenemos alguno, debería estar aquí. 
SOURCES       = main.cpp
OBJECTS       = main.o
[snip]
QMAKE_TARGET  = qapp
DESTDIR       = 
TARGET        = qapp  # Objetivo por defecto para construir

first: all            # para consstruir "first" debemos construir "all"

####### Reglas Implícitas

.SUFFIXES: .c .o .cpp .cc .cxx .C

.cpp.o:
	$(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $<

## Posibles objetivos para construir

all: Makefile $(TARGET)  # esto es como se construye "all"

$(TARGET):  $(OBJECTS) $(OBJMOC)    # esto es como se construye qapp
	$(LINK) $(LFLAGS) -o $(TARGET) $(OBJECTS) $(OBJMOC) $(OBJCOMP) \
    $(LIBS)

        qmake:  FORCE               # ¡"qmake" es un objetivo también!  
	@$(QMAKE) -o Makefile qapp.pro  # ¿que hizo esto?

dist:                               # Otro objetivo 
	@mkdir -p .tmp/qapp \
    && $(COPY_FILE) --parents $(SOURCES) $(HEADERS) \ 
       $(FORMS) $(DIST) .tmp/qapp/ \ 
    &&  (cd `dirname .tmp/qapp` \ && $(TAR) qapp.tar qapp \ 
         && $(COMPRESS) qapp.tar) \ 
    && $(MOVE) `dirname .tmp/qapp`/qapp.tar.gz . \ 
    && $(DEL_FILE) -r .tmp/qapp

clean:compiler_clean                # otro objetivo más
	-$(DEL_FILE) $(OBJECTS)
	-$(DEL_FILE) *~ core *.core


####### Dependencias para reglas implícitas

main.o: main.cpp 


El comando make revisa las dependencias y realiza cada paso de construcción del Makefile. El nombre y ubicación del resultado final puede ser establecido con las variables del proyecto TARGET y target.path. Si TARGET no es especificado, el nombre por defecto dado es el nombre del directorio en el que el archivo del proyecto se aloja. Si target.path no se especifica, la localización por defecto es el directorio en el que el proyecto se ubica.

Limpiando Archivos[editar]

make puede limpiar los archivos generados por tí por medio de dos objetivos, clean y distclean. Observa cómo ambos son distintos:

src/qapp> make clean
rm -f main.o
rm -f *~ core *.core
src/qapp> ls
 Makefile  main.cpp  qapp  qapp.pro
src/qapp> make distclean
rm -f qmake_image_collection.cpp
rm -f main.o
rm -f *~ core *.core
rm -f qapp
rm -f Makefile
src/qapp> ls
 main.cpp  qapp.pro


Después de un make distclean, los únicos archivos que restan son los de las fuentes que pueden ir dentro de una tarball para su distribución


Nota:
Si modificas un archivo de proyecto desde la última ejecución de make, la siguiente invocación de make debería reconstruir el Makefile mismo (por medio de qmake) antes de volver a correr make sobre el nuevo Makefile generado.


En otras palabras, el Makefile es sencible a qmake y puede rehacerse a sí mismo.



Consejo: make dist
El comando make dist creará un tarball (nombre_del_directorio.tar.gz) que contenga todos los archivos fuente sobre los que el proyecto tenga conocimiento.


Así como nosotros agregamos más codigo fuente, cabeceras o módulos de librerías para nuestro proyecto, editamos el archivo .pro y añadimos los nuevos elementos a las listas SOURCES, HEADERS, y LIBS. La misma documentación standard que aplica también para el código fuente de C++ debería ser aplicada a los archivos de proyecto (con los comentarios comenzando con #).


Pensemos en el archivo de proyecto como un mapa de nuestro proyecto, conteniendo referencias para todos los archivos y localizaciones requeridas para construir nuestra aplicación o librería. Como otros archivos fuente, este es tanto leible por humanos como por la máquina. El archivo .pro es el primer lugar para mirar cuando encontramos mensajes not found o undefined durante el proceso de construcción (especialmente en el momento del enlace). Para más detalles recomendamos que leas la Guía para qmake de Trolltech.


Versión para imprimir esta pagina

  1. Dependiendo de tu entorno de desarrollo, este programa puede tener algúnos otros nombres como mingw32-make, nmake, gmake, o unsermake.